1.5.1 在明确语法上使用 GLR

在最简单的情况下，您可以使用 GLR 算法 解析明确但不能成为 LR（1） 的语法。 这种语法通常需要不止一个前瞻符号。

考虑一个问题 出现在枚举类型和子范围类型的声明中 编程语言 Pascal.以下是一些示例：

type subrange = lo .. hi;
type enum = (a, b, c);

原始语言标准只允许使用数字文字和常量 子范围边界（'' 和 ''）的标识符，但 Extended Pascal （ISO/IEC 10206） 和许多其他 Pascal 实现允许任意 那里的表达式。这导致了以下情况，其中包含 多余的一对括号：lohi

type subrange = (a) .. b;

将此与以下枚举声明进行比较 键入只有一个值：

type enum = (a);

（这些声明是人为的，但它们在语法上是有效的，并且 更复杂的情况可能会出现在实际程序中。

这两个声明在“”标记之前看起来完全相同。跟 正常 LR（1） 单令牌前瞻，不可能在 解析标识符“”时的两种形式。然而，这是可取的 让解析器来决定这一点，因为在后一种情况下，“'”必须变成 新标识符表示枚举值，而在前一种情况下 '' 必须用其当前含义来评估，这可能是一个常数 甚至是函数调用。..aaa

您可以将“”解析为“括号中的未指定标识符”， 稍后解决，但这通常需要大量扭曲 语义动作和大部分语法，其中括号 嵌套在表达式的递归规则中。(a)

您可以考虑使用词法分析器来区分这两种形式 为当前定义和未定义的标识符返回不同的标记。 但是，如果这些声明发生在本地范围内，并且 一个外部范围，那么两种形式都是可能的——要么局部重新定义 ''，或使用外部作用域中的值 ''。所以这个 方法行不通。aaa

此问题的简单解决方案是声明解析器以使用 GLR 算法。当 GLR 解析器达到临界状态时，它只是分裂 并同时遵循两个语法规则。早点或 后来，其中一个遇到解析错误。如果有“”令牌 在下一个 '' 之前，枚举类型的规则将失败，因为它 在任何地方都不能接受“”;否则，子范围类型规则将失败 因为它需要一个“”令牌。所以其中一个分支无声地失败了， 另一个继续正常，执行所有中间 在拆分期间推迟的操作。..;....

如果输入在语法上不正确，则两个分支都失败，并且解析器 像往常一样报告语法错误。

所有这一切的效果是解析器似乎“猜”到了正确的 分支来采取，或者换句话说，它似乎比 底层的 LR（1） 算法实际上允许。在此示例中，LR（2） 就足够了，但对于任何 k 来说，一些不是 LR（k） 的情况也可以这样处理。

通常，GLR 解析器可以采用二次或三次最坏情况时间，并且 对于某些人来说，当前的 Bison 解析器甚至需要指数级的时间和空间 语法。在实践中，这种情况很少发生，对于许多语法来说，确实如此 可能证明它不会发生。本示例仅包含 两个规则之间的一个冲突，以及包含 冲突不能嵌套。因此，可以存在于 任何时间都受到常数 2 的限制，解析时间仍然是线性的。

这是与上述示例相对应的 Bison 语法。它 解析 Pascal 类型声明的大幅简化形式。

%token TYPE DOTDOT ID

%left '+' '-'
%left '*' '/'

%%
type_decl: TYPE ID '=' type ';' ;

type:
  '(' id_list ')'
| expr DOTDOT expr
;

id_list:
  ID
| id_list ',' ID
;

expr:
  '(' expr ')'
| expr '+' expr
| expr '-' expr
| expr '*' expr
| expr '/' expr
| ID
;

当用作正常的 LR（1） 语法时，Bison 会正确地抱怨 关于一个减少/减少冲突。在冲突的情况下， 解析器选择其中一个备选方案，任意选择一个 首先声明。因此，以下正确输入不是 认可：

type t = (a) .. b;

解析器可以变成 GLR 解析器，同时还可以告诉 Bison 要对一个已知的减少/减少冲突保持沉默，请添加 这两个声明对 Bison 语法文件（在第一个之前） ‘’):%%

%glr-parser
%expect-rr 1

不需要改变语法本身。现在，解析器可以识别所有 根据上述有限的语法，有效的声明是透明的。 事实上，用户甚至没有注意到解析器何时分裂。

因此，这里我们有一个案例，我们可以利用 GLR 的优势，几乎没有 弊。然而，即使在像这样的简单情况下，至少也有 需要注意两个潜在的问题。首先，始终分析冲突 由 Bison 报告，以确保 GLR 拆分仅在原地完成 打算。无意中拆分 GLR 解析器可能会导致较少的问题 比 LR 解析器静态选择错误的替代方案更明显 冲突。其次，要非常谨慎地考虑与词法分析器的交互（参见 Token Kinds 中的语义信息）。由于拆分解析器使用没有 在拆分过程中执行任何操作，词法分析器都无法获得信息 通过解析器操作。词法分析器相互作用的一些情况可以通过以下方式消除 使用 GLR 将复杂功能从词法分析器转移到解析器。你必须 检查其余案例的正确性。

在我们的示例中，词法分析器可以安全地返回基于以下 它们在某个符号表中的当前含义，因为没有新符号 在类型声明的中间定义。虽然有可能 解析器，用于在解析枚举常量时定义枚举常量，在 类型声明完成，实际上没有区别，因为它们 不能在同一枚举类型声明中使用。

1.5.2 使用 GLR 解决歧义

让我们考虑一个示例，从 C++ 大大简化 语法。¹

%{
  #include <stdio.h>
  int yylex (void);
  void yyerror (char const *);
%}

%define api.value.type {char const *}

%token TYPENAME ID

%right '='
%left '+'

%glr-parser

%%

prog:
  %empty
| prog stmt   { printf ("\n"); }
;

stmt:
  expr ';'  %dprec 1
| decl      %dprec 2
;

expr:
  ID               { printf ("%s ", $$); }
| TYPENAME '(' expr ')'
                   { printf ("%s <cast> ", $1); }
| expr '+' expr    { printf ("+ "); }
| expr '=' expr    { printf ("= "); }
;

decl:
  TYPENAME declarator ';'
                   { printf ("%s <declare> ", $1); }
| TYPENAME declarator '=' expr ';'
                   { printf ("%s <init-declare> ", $1); }
;

declarator:
  ID               { printf ("\"%s\" ", $1); }
| '(' declarator ')'
;

这模拟了 C++ 语法的一个有问题的部分——之间的歧义 某些声明和声明。例如

T (x) = y+z;

解析为 an 或 a（假设 '' 被识别为 a 和 '' 作为 ）。 Bison 将此检测为规则 和 之间的 reduce/reduce 冲突，它无法在 在上面的示例中遇到的时间。由于这是一个 GLR 解析器，因此它将问题拆分为两个解析，一个用于 解决 reduce/reduce 冲突的每个选择。 与上一节中的示例不同（请参阅在明确语法上使用 GLR）， 然而，这些解析都没有“死亡”，因为它的语法是 模糊。其中一个解析器最终会减少和 另一个 reduce ，之后两个解析器都处于 相同的状态：他们看到了“”，并且具有相同的未处理状态 剩余输入。我们说这些解析已经合并。exprstmtTTYPENAMExIDexpr : IDdeclarator : IDxstmt : expr ';'stmt : declprog stmt

此时，GLR 解析器需要 如何在竞争解析之间进行选择的语法。 在上面的示例中，两个声明指定 Bison 优先 到将示例解释为 的解析，这意味着 that 是一个声明器。 因此，解析器打印%dprecdeclx

"x" y z + T <init-declare>

只有当多个声明时，这些声明才会发挥作用 解析幸存下来。请考虑此解析器的不同输入字符串：%dprec

T (x) + y;

这是使用 GLR 解析明确 构造，如上一节所示（请参阅在明确语法上使用 GLR）。 在这里，没有歧义（这不能解析为声明）。 但是，当 Bison 解析器遇到 时，它没有 有足够的信息来解决减少/减少冲突（再次， 之间作为 an 或 a ）。在这个 case，则不使用优先级声明。同样，解析器分裂 一分为二，一个假设是 ，另一个假设是 假设是 .这些解析器中的第二个 然后在看到 时消失，解析器打印xxexprdeclaratorxexprxdeclarator+

x T <cast> y +

假设您不想解决歧义，而是想看到所有内容 可能性。为此，必须合并语义 两个可能的解析器的操作，而不是选择一个而不是 其他。为此，您可以更改 遵循：stmt

stmt:
  expr ';'  %merge <stmt_merge>
| decl      %merge <stmt_merge>
;

并将函数定义为：stmt_merge

static YYSTYPE
stmt_merge (YYSTYPE x0, YYSTYPE x1)
{
  printf ("<OR> ");
  return "";
}

并附有远期声明 在文件开头的 C 声明中：

%{
  static YYSTYPE stmt_merge (YYSTYPE x0, YYSTYPE x1);
%}

使用这些声明，生成的分析器将分析第一个示例 作为 an 和 a ，并打印exprdecl

"x" y z + T <init-declare> x T <cast> y z + = <OR>

Bison 要求所有 参与任何特定合并的作品具有相同的 '' 子句。否则，歧义将无法解决， 解析器将在任何解析期间报告错误，导致 有问题的合并。%merge

合并的签名取决于符号的类型。在 前面的示例中，合并到符号 （） 没有 特定类型，合并为stmt

YYSTYPE stmt_merge (YYSTYPE x0, YYSTYPE x1);

但是，如果具有声明的类型，例如，stmt

%type <Node *> stmt;

或

%union {
  Node *node;
  ...
};

%type <node> stmt;

那么合并的原型必须是：

Node *stmt_merge (YYSTYPE x0, YYSTYPE x1);

（这个签名最初可能是一个错误，也许它应该是一个错误 ‘’.如果您对以下内容有意见 它，请告诉我们。Node *stmt_merge (Node *x0, Node *x1)

1.5.3 GLR语义操作

GLR 解析的性质和生成的结构 解析器对语义值和操作产生了某些限制。

• 延迟语义操作
• YY错误
• 对语义值和位置的限制

1.5.4 使用任意谓词控制解析

除了 和 指令之外， GLR 解析器 允许您根据执行的任意计算拒绝解析 在用户代码中，而没有让 Bison 将此拒绝视为错误 如果有替代解析。例如%dprec%merge

widget:
  %?{  new_syntax } "widget" id new_args  { $$ = f($3, $4); }
| %?{ !new_syntax } "widget" id old_args  { $$ = f($3, $4); }
;

是允许同一解析器处理两种不同语法的一种方法 部件。前面的从句被视为普通条款 Midrule 操作，除了其文本作为表达式处理并且始终 立即评估（即使在非确定性模式下）。如果 表达式产生 0 （false），该子句被视为语法错误， 在非确定性解析器中，这会导致减少它的堆栈 去死。在确定性解析器中，它的行为类似于 .%?YYERROR

如示例所示，谓词在其他方面看起来像语义操作，并且 因此，在确定数字时必须考虑它们 用于表示右侧符号的语义值。 但是，谓词动作没有定义的值，并且可能不会给出 标签。

语义谓词和普通谓词之间存在细微的区别 非确定性模式下的操作，因为后者是延迟的。 例如，我们可以尝试将前面的示例重写为

widget:
  { if (!new_syntax) YYERROR; }
    "widget" id new_args  { $$ = f($3, $4); }
|  { if (new_syntax) YYERROR; }
    "widget" id old_args  { $$ = f($3, $4); }
;

（颠倒谓词测试的意义，当它们 false）。但是，这 如果 和 具有重叠的语法，则不具有相同的效果。 由于 midrule 操作测试被推迟， GLR 解析器首先遇到未解决的模棱两可的约简 对于在执行 的测试之前识别同一字符串的情况。因此，它 报告错误。new_argsold_argsnew_syntaxnew_argsold_argsnew_syntax

最后，在写谓词时要小心：推迟的操作没有 assessd，因此在谓词中使用它们将产生未定义的效果。

2.1.1 声明rpcalc

以下是反向波兰符号的 C 和 Bison 声明 计算器。与 C 语言一样，注释位于 '' 或 在“”之后。/*…*///

/* Reverse Polish Notation calculator. */

%{
  #include <stdio.h>
  #include <math.h>
  int yylex (void);
  void yyerror (char const *);
%}

%define api.value.type {double}
%token NUM

%% /* Grammar rules and actions follow. */

声明部分（见序言）包含两个 预处理器指令和两个前向声明。

该指令用于声明幂 功能。#includepow

和 的转发声明是 需要，因为 C 语言要求声明函数 在使用之前。这些函数将在 结语，但解析器调用它们，因此必须在 序幕。yylexyyerror

第二部分，野牛声明，向野牛提供关于 令牌及其类型（参见 Bison 声明部分）。

该指令定义变量 ， 从而为标记和 分组（请参阅语义值的数据类型）。野牛 解析器将使用定义为的任何类型;如果你 不要定义它，是默认设置。因为我们指定 ''，每个标记和每个表达式都有一个关联的值， 这是一个浮点数。C代码可以用来指代 值 。%defineapi.value.typeapi.value.typeint{double}YYSTYPEapi.value.type

每个不是单字符文字的终端符号都必须是 宣布。（单字符文字通常不需要声明。 在此示例中，所有算术运算符都由 单字符文字，因此唯一需要的终端符号 声明为 ，数值常量的标记类型。NUM

2.1.2 语法规则rpcalc

以下是反向波兰语符号计算器的语法规则。

input:
  %empty
| input line
;

line:
  '\n'
| exp '\n'      { printf ("%.10g\n", $1); }
;

exp:
  NUM
| exp exp '+'   { $$ = $1 + $2;      }
| exp exp '-'   { $$ = $1 - $2;      }
| exp exp '*'   { $$ = $1 * $2;      }
| exp exp '/'   { $$ = $1 / $2;      }
| exp exp '^'   { $$ = pow ($1, $2); }  /* Exponentiation */
| exp 'n'       { $$ = -$1;          }  /* Unary minus   */
;

%%

此处定义的 rpcalc“语言”的分组是表达式 （给定名称）、输入行 （） 和 完整的输入成绩单 （）。这些非终端中的每一个 符号有几个替代规则，由竖条“”连接 读作“或”。以下各节介绍了这些规则的内容 意味 着。explineinput|

语言的语义是由当 识别分组。这些操作是出现在里面的 C 代码 括号。请参阅操作。

您必须在 C 中指定这些操作，但 Bison 提供了 在规则之间传递语义值。在每个操作中， 伪变量代表分组的语义值 规则将要构建。赋值 是 大多数动作的主要工作。组件的语义值 规则称为 、 等。$$$$$1$2

• 输入说明
• 行说明
• exp 的解释

input:
  %empty
| input line
;

line:
  '\n'
| exp '\n'  { printf ("%.10g\n", $1); }
;

exp:
  NUM
| exp exp '+'     { $$ = $1 + $2;    }
| exp exp '-'     { $$ = $1 - $2;    }
…
;

exp: NUM;
exp: exp exp '+'  { $$ = $1 + $2; };
exp: exp exp '-'  { $$ = $1 - $2; };
…

exp: NUM | exp exp '+' {$$ = $1 + $2; } | … ;

exp:
  NUM
| exp exp '+'    { $$ = $1 + $2; }
| …
;

2.1.3 词汇分析器rpcalc

词汇分析器的工作是低级解析：转换字符 或将字符序列转换为标记。Bison 解析器得到它的 通过调用词法分析器来标记。请参阅 Lexical Analyzer 函数 yylex。

RPN 只需要一个简单的词法分析器 计算器。这 词法分析器跳过空格和制表符，然后读取数字 as 并将它们作为标记返回。任何其他字符 那不是数字的一部分，而是一个单独的令牌。请注意，令牌代码 对于这样的单字符标记就是字符本身。doubleNUM

词法分析器函数的返回值是一个数字代码，它 表示令牌类型。野牛规则中使用的相同文本代表 此标记类型也是该类型的数字代码的 C 表达式。 这以两种方式工作。如果令牌类型是字符文字，则其 数字代码是字符的数字代码;您可以使用相同的字符 字面上表示数字。如果令牌种类是 一个标识符，该标识符由 Bison 定义为 C 枚举，其 definition 是适当的代码。因此，在此示例中，成为要使用的枚举。NUMyylex

令牌的语义值（如果有）存储在全局 变量 ，这是 Bison 解析器将查找它的位置。 （的 C 数据类型是 ，其值已定义 在语法的开头通过“”;请参阅 rpcalc 的声明。yylvalyylvalYYSTYPE%define api.value.type {double}

如果遇到输入结束，则返回令牌种类代码 0。 （Bison 将任何非正值识别为表示输入结束。

下面是词法分析器的代码：

/* The lexical analyzer returns a double floating point
   number on the stack and the token NUM, or the numeric code
   of the character read if not a number.  It skips all blanks
   and tabs, and returns 0 for end-of-input. */

#include <ctype.h>
#include <stdlib.h>

int
yylex (void)
{
  int c = getchar ();
  /* Skip white space. */
  while (c == ' ' || c == '\t')
    c = getchar ();

  /* Process numbers. */
  if (c == '.' || isdigit (c))
    {
      ungetc (c, stdin);
      if (scanf ("%lf", &yylval) != 1)
        abort ();
      return NUM;
    }

  /* Return end-of-input. */
  else if (c == EOF)
    return YYEOF;
  /* Return a single char. */
  else
    return c;
}

2.1.4 控制功能

根据这个例子的精神，控制功能是 保持在最低限度。唯一的要求是它调用以启动解析过程。yyparse

int
main (void)
{
  return yyparse ();
}

2.1.5 错误报告例程

当检测到语法错误时，它会调用错误报告 函数打印错误消息（通常但不是 总是 ）。由程序员提供（参见解析器 C 语言接口），所以 以下是我们将使用的定义：yyparseyyerror"syntax error"yyerror

#include <stdio.h>

/* Called by yyparse on error. */
void
yyerror (char const *s)
{
  fprintf (stderr, "%s\n", s);
}

返回后，Bison 解析器可能会从错误中恢复 如果语法包含合适的错误规则，则继续解析 （请参阅错误恢复）。否则，返回非零。我们 在此示例中没有编写任何错误规则，因此任何无效的输入都会 导致计算器程序退出。这不是干净的行为 真正的计算器，但对于第一个例子来说已经足够了。yyerroryyparse

2.1.6 运行 Bison 来制作解析器

在运行 Bison 生成解析器之前，我们需要决定如何 将所有源代码排列在一个或多个源文件中。对于这样的 简单的例子，最简单的事情就是把所有东西都放在一个文件中， 语法文件。和 的定义在语法文件的尾声中 （参见 The Overall Layout of a Bison Grammar）。yylexyyerrormain

对于一个大型项目，您可能有多个源文件，并用于安排重新编译它们。make

对于语法文件中的所有源代码，您可以使用以下命令 要将其转换为解析器实现文件，请执行以下操作：

$ bison file.y

在此示例中，语法文件被调用 （for “反向波兰 CALCulator”）。Bison 生成解析器 实现文件，删除了 '' 从语法文件名中。分析器实现文件 包含 的源代码。附加功能 在语法文件中 （， 和 ） 是 逐字复制到解析器实现文件。rpcalc.yfile.tab.c.yyyparseyylexyyerrormain

2.1.7 编译解析器实现文件

以下是编译和运行解析器实现文件的方法：

# List files in current directory.
$ ls
rpcalc.tab.c  rpcalc.y

# Compile the Bison parser.
# -lm tells compiler to search math library for pow.
$ cc -lm -o rpcalc rpcalc.tab.c

# List files again.
$ ls
rpcalc  rpcalc.tab.c  rpcalc.y

该文件现在包含可执行代码。这是一个 使用 的示例会话。rpcalcrpcalc

$ rpcalc
4 9 +
⇒ 13
3 7 + 3 4 5 *+-
⇒ -13
3 7 + 3 4 5 * + - n              Note the unary minus, ‘n’
⇒ 13
5 6 / 4 n +
⇒ -3.166666667
3 4 ^                            Exponentiation
⇒ 81
^D                               End-of-file indicator
$

2.4.1 声明ltcalc

位置跟踪计算器的 C 和 Bison 声明是 与中缀表示法计算器的声明相同。

/* Location tracking calculator. */

%{
  #include <math.h>
  int yylex (void);
  void yyerror (char const *);
%}

/* Bison declarations. */
%define api.value.type {int}
%token NUM

%left '-' '+'
%left '*' '/'
%precedence NEG
%right '^'

%% /* The grammar follows. */

请注意，没有特定于位置的声明。定义数据类型 对于不需要存储位置：我们将使用 默认值（请参阅位置的数据类型），这是一个四成员结构，具有 以下整数字段：、 和 。按照惯例，并按照 根据 GNU 编码标准和惯例，行数和列数 两者都从 1 开始。first_linefirst_columnlast_linelast_column

2.4.2 语法规则ltcalc

是否处理位置对 your 的语法没有影响 语言。因此，此示例的语法规则将非常接近 对于上一个示例中的那些：我们只会修改它们以使其受益 从新信息。

在这里，我们将使用位置来报告除以零，并找到 错误的表达式或子表达式。

input:
  %empty
| input line
;

line:
  '\n'
| exp '\n' { printf ("%d\n", $1); }
;

exp:
  NUM
| exp '+' exp   { $$ = $1 + $3; }
| exp '-' exp   { $$ = $1 - $3; }
| exp '*' exp   { $$ = $1 * $3; }

| exp '/' exp
    {
      if ($3)
        $$ = $1 / $3;
      else
        {
          $$ = 1;
          fprintf (stderr, "%d.%d-%d.%d: division by zero",
                   @3.first_line, @3.first_column,
                   @3.last_line, @3.last_column);
        }
    }

| '-' exp %prec NEG     { $$ = -$2; }
| exp '^' exp           { $$ = pow ($1, $3); }
| '(' exp ')'           { $$ = $2; }

此代码演示如何通过以下方式到达语义操作中的位置 使用规则组件的伪变量，以及 分组的伪变量。@n@$

我们不需要为：输出解析器赋值 自然而然。默认情况下，在执行每个操作的 C 代码之前，对于包含组件的规则，设置为从 的开头到结尾的范围。此行为可以是 重新定义（请参阅位置的默认操作），对于非常具体的规则，可以手动计算。@$@$@1@nn@$

2.4.3 词汇分析器。ltcalc

到目前为止，我们依靠 Bison 的默认设置来启用位置 跟踪。下一步是重写词法分析器，并使其 能够向解析器提供令牌位置，就像它已经为 语义值。

为此，我们必须考虑到 输入文本，以避免计算位置模糊或错误：

int
yylex (void)
{
  int c;

  /* Skip white space. */
  while ((c = getchar ()) == ' ' || c == '\t')
    ++yylloc.last_column;

  /* Step. */
  yylloc.first_line = yylloc.last_line;
  yylloc.first_column = yylloc.last_column;

  /* Process numbers. */
  if (isdigit (c))
    {
      yylval = c - '0';
      ++yylloc.last_column;
      while (isdigit (c = getchar ()))
        {
          ++yylloc.last_column;
          yylval = yylval * 10 + c - '0';
        }
      ungetc (c, stdin);
      return NUM;
    }

  /* Return end-of-input. */
  if (c == EOF)
    return YYEOF;

  /* Return a single char, and update location. */
  if (c == '\n')
    {
      ++yylloc.last_line;
      yylloc.last_column = 0;
    }
  else
    ++yylloc.last_column;
  return c;
}

基本上，词法分析器执行与以前相同的处理：它 跳过空格和制表符，并读取数字或单字符标记。在 此外，它还会更新包含令牌位置的全局变量（类型）。yyllocYYLTYPE

现在，每次此函数返回令牌时，解析器的类型为 以及它的语义价值，以及它在文本中的位置。最后需要的 更改是初始化，例如在控制 功能：yylloc

int
main (void)
{
  yylloc.first_line = yylloc.last_line = 1;
  yylloc.first_column = yylloc.last_column = 0;
  return yyparse ();
}

请记住，计算位置不是语法问题。每 字符必须与位置更新相关联，无论它是否在 有效输入、注释、文本字符串等。

2.5.1 声明mfcalc

以下是多功能的 C 和 Bison 声明 计算器。

%{
  #include <stdio.h>  /* For printf, etc. */
  #include <math.h>   /* For pow, used in the grammar. */
  #include "calc.h"   /* Contains definition of 'symrec'. */
  int yylex (void);
  void yyerror (char const *);
%}

%define api.value.type union /* Generate YYSTYPE from these types: */
%token <double>  NUM     /* Double precision number. */
%token <symrec*> VAR FUN /* Symbol table pointer: variable/function. */
%nterm <double>  exp

%precedence '='
%left '-' '+'
%left '*' '/'
%precedence NEG /* negation--unary minus */
%right '^'      /* exponentiation */

上面的语法只介绍了Bison语言的两个新功能。 这些功能允许语义值具有各种数据类型 （请参阅多个值类型）。

分配给变量的特殊值指定使用符号的数据定义符号 类型。Bison 将生成 to 的适当定义 存储这些值。union%defineapi.value.typeYYSTYPE

由于值现在可以具有各种类型，因此必须关联类型 使用其语义值的每个语法符号。这些符号是 、 、 和 。他们的声明是 使用其数据类型（放置在尖括号之间）进行扩充。为 实例中，则 的值存储在 中。NUMVARFUNexpNUMdouble

Bison 构造用于声明非终端符号， 就像用于声明令牌种类一样。以前我们做过 之前不使用，因为非终端符号通常 由定义它们的规则隐式声明。但必须 显式声明，以便我们可以指定其值类型。请参阅非终端符号。%nterm%token%ntermexp

2.5.2 语法规则mfcalc

以下是多功能计算器的语法规则。 它们中的大多数是直接从 ;三条规则， 那些提到 或 的，是新的。calcVARFUN

%% /* The grammar follows. */

input:
  %empty
| input line
;

line:
  '\n'
| exp '\n'   { printf ("%.10g\n", $1); }
| error '\n' { yyerrok;                }
;

exp:
  NUM
| VAR                { $$ = $1->value.var;              }
| VAR '=' exp        { $$ = $3; $1->value.var = $3;     }
| FUN '(' exp ')'    { $$ = $1->value.fun ($3);         }
| exp '+' exp        { $$ = $1 + $3;                    }
| exp '-' exp        { $$ = $1 - $3;                    }
| exp '*' exp        { $$ = $1 * $3;                    }
| exp '/' exp        { $$ = $1 / $3;                    }
| '-' exp  %prec NEG { $$ = -$2;                        }
| exp '^' exp        { $$ = pow ($1, $3);               }
| '(' exp ')'        { $$ = $2;                         }
;

/* End of grammar. */
%%

2.5.3 符号表mfcalc

多功能计算器需要一个符号表来跟踪 变量和函数的名称和含义。这不会影响 语法规则（动作除外）或野牛声明，但它 需要一些额外的 C 函数来支持。

符号表本身由记录链表组成。其 定义，保留在标题中，如下所示。它 提供要放置在表中的函数或变量。calc.h

/* Function type. */
typedef double (func_t) (double);

/* Data type for links in the chain of symbols. */
struct symrec
{
  char *name;  /* name of symbol */
  int type;    /* type of symbol: either VAR or FUN */
  union
  {
    double var;    /* value of a VAR */
    func_t *fun;   /* value of a FUN */
  } value;
  struct symrec *next;  /* link field */
};

typedef struct symrec symrec;

/* The symbol table: a chain of 'struct symrec'. */
extern symrec *sym_table;

symrec *putsym (char const *name, int sym_type);
symrec *getsym (char const *name);

新版本的 will 调用来初始化 符号表：maininit_table

struct init
{
  char const *name;
  func_t *fun;
};

struct init const funs[] =
{
  { "atan", atan },
  { "cos",  cos  },
  { "exp",  exp  },
  { "ln",   log  },
  { "sin",  sin  },
  { "sqrt", sqrt },
  { 0, 0 },
};

/* The symbol table: a chain of 'struct symrec'. */
symrec *sym_table;

/* Put functions in table. */
static void
init_table (void)

{
  for (int i = 0; funs[i].name; i++)
    {
      symrec *ptr = putsym (funs[i].name, FUN);
      ptr->value.fun = funs[i].fun;
    }
}

只需编辑初始化列表并添加必要的包含 文件，您可以向计算器添加其他函数。

两个重要功能允许在 符号表。向函数传递名称和种类 （ 或 ） 的对象。对象是 链接到列表的前面，并返回指向该对象的指针。 该函数将传递要查找的符号的名称。如果 找到，则返回指向该符号的指针;否则返回零。putsymVARFUNgetsym

/* The mfcalc code assumes that malloc and realloc
   always succeed, and that integer calculations
   never overflow.  Production-quality code should
   not make these assumptions.  */
#include <assert.h>
#include <stdlib.h> /* malloc, realloc. */
#include <string.h> /* strlen. */

symrec *
putsym (char const *name, int sym_type)
{
  symrec *res = (symrec *) malloc (sizeof (symrec));
  res->name = strdup (name);
  res->type = sym_type;
  res->value.var = 0; /* Set value to 0 even if fun. */
  res->next = sym_table;
  sym_table = res;
  return res;
}

symrec *
getsym (char const *name)
{
  for (symrec *p = sym_table; p; p = p->next)
    if (strcmp (p->name, name) == 0)
      return p;
  return NULL;
}

2.5.4 莱克斯mfcalc

该函数现在必须识别变量、数值和 单字符算术运算符。字母数字字符串 带有前导字母的字符被识别为变量或 函数取决于符号表对它们的说明。yylex

字符串将传递给符号表中的查找。如果 该名称将显示在表中，指针指向其位置和类型 （ 或 ） 返回到 。如果不是 已经在表中，则将其作为 using .同样，指针及其类型（必须是 ）是 返回 .getsymVARFUNyyparseVARputsymVARyyparse

在处理数值和算术时不需要更改 中的运算符。yylex

#include <ctype.h>
#include <stddef.h>

int
yylex (void)
{
  int c = getchar ();

  /* Ignore white space, get first nonwhite character. */
  while (c == ' ' || c == '\t')
    c = getchar ();

  if (c == EOF)
    return YYEOF;

  /* Char starts a number => parse the number. */
  if (c == '.' || isdigit (c))
    {
      ungetc (c, stdin);
      if (scanf ("%lf", &yylval.NUM) != 1)
        abort ();
      return NUM;
    }

Bison 生成了一个定义，其中有一个名为存储符号值的成员。YYSTYPENUMNUM

  /* Char starts an identifier => read the name. */
  if (isalpha (c))
    {
      static ptrdiff_t bufsize = 0;
      static char *symbuf = 0;

      ptrdiff_t i = 0;
      do

        {
          /* If buffer is full, make it bigger. */
          if (bufsize <= i)
            {
              bufsize = 2 * bufsize + 40;
              symbuf = realloc (symbuf, (size_t) bufsize);
            }
          /* Add this character to the buffer. */
          symbuf[i++] = (char) c;
          /* Get another character. */
          c = getchar ();
        }

      while (isalnum (c));

      ungetc (c, stdin);
      symbuf[i] = '\0';

      symrec *s = getsym (symbuf);
      if (!s)
        s = putsym (symbuf, VAR);
      yylval.VAR = s; /* or yylval.FUN = s. */
      return s->type;
    }

  /* Any other character is a token by itself. */
  return c;
}

2.5.5 主要mfcalc

错误报告功能保持不变，新版本包括对用户需求的调用和设置（有关详细信息，请参阅跟踪解析器）：maininit_tableyydebug

/* Called by yyparse on error. */
void yyerror (char const *s)
{
  fprintf (stderr, "%s\n", s);
}

int main (int argc, char const* argv[])

{
  /* Enable parse traces on option -p. */
  if (argc == 2 && strcmp(argv[1], "-p") == 0)
    yydebug = 1;

  init_table ();
  return yyparse ();
}

该程序既强大又灵活。您可以轻松添加新的 函数，修改此代码进行安装是一项简单的工作 预定义的变量，例如 OR 以及。pie

3.1.1 序幕

该部分包含宏定义和 在语法规则中的操作中使用的函数和变量。 这些被复制到解析器实现文件的开头，以便 它们先于 . 的定义之前。您可以使用“' 从头文件中获取声明。如果你不需要任何 C 声明，您可以省略 '' 和 '' 分隔符 将此部分括起来。Prologueyyparse#include%{%}

该部分因首次出现 “'”位于注释、字符串文本或字符之外 不断。Prologue%}

您可能有多个部分，与 .这允许您拥有 C 和 Bison 声明 相互指代。例如，声明可以 使用头文件中定义的类型，您可能希望对函数进行原型设计 采用类型的参数。这可以通过两个块来完成，一个在声明之前，一个在声明之后。PrologueBison declarations%unionYYSTYPEPrologue%union

%{
  #define _GNU_SOURCE
  #include <stdio.h>
  #include "ptypes.h"
%}

%union {
  long n;
  tree t;  /* tree is defined in ptypes.h. */
}

%{
  static void print_token (yytoken_kind_t token, YYSTYPE val);
%}

…

当有疑问时，通常将序幕代码放在所有 Bison 之前会更安全 声明，而不是之后。例如，要素的任何定义 测试宏，例如或应该出现 在所有 Bison 声明之前，因为特征测试宏会影响 Bison 生成的指令的行为。_GNU_SOURCE_POSIX_C_SOURCE#include

3.1.2 序幕替代方案

部分的功能通常可以是微妙的，并且 死板。作为替代方案，Bison 提供了一个指令 显式限定符字段，用于标识代码的用途和 因此，Bison 应该生成它的位置。对于 C/C++， 默认位置可以省略限定符，也可以是 、 、 之一。请参见%code 摘要。Prologue%coderequiresprovidestop

再看一下上一节的示例：

%{
  #define _GNU_SOURCE
  #include <stdio.h>
  #include "ptypes.h"
%}

%union {
  long n;
  tree t;  /* tree is defined in ptypes.h. */
}

%{
  static void print_token (yytoken_kind_t token, YYSTYPE val);
%}

…

请注意，这里有两个部分，但有一个微妙的部分 它们的功能之间的区别。例如，如果您决定 覆盖 Bison 的默认定义 ，您应该在哪个部分编写新的 定义？⁵ 你应该 首先编写它，因为 Bison 会将该代码插入解析器 实现文件之前的默认定义。在 您应该在哪个部分构建一个内部函数的原型，该函数接受 和 作为 参数？您应该在第二个中对其进行原型设计，因为 Bison 将插入 该代码在 和 定义之后。PrologueYYLTYPEPrologueYYLTYPEProloguetrace_tokenYYLTYPEyytoken_kind_tYYLTYPEyytoken_kind_t

这两个部分在功能上的区别是 由他们之间的外观建立。这 行为引发了一些问题。首先，为什么 a 的位置会影响与 和 相关的定义？第二，如果没有呢？在那 情况下，第二种部分不可用。这 行为并不直观。Prologue%union%unionYYLTYPEyytoken_kind_t%unionPrologue

为了避免这种微妙的依赖关系，请使用 a 和 unqualified 重写示例。让我们继续添加 新定义和原型 同时：%union%code top%codeYYLTYPEtrace_token

%code top {
  #define _GNU_SOURCE
  #include <stdio.h>

  /* WARNING: The following code really belongs
   * in a '%code requires'; see below. */

  #include "ptypes.h"
  #define YYLTYPE YYLTYPE
  typedef struct YYLTYPE
  {
    int first_line;
    int first_column;
    int last_line;
    int last_column;
    char *filename;
  } YYLTYPE;
}

%union {
  long n;
  tree t;  /* tree is defined in ptypes.h. */
}

%code {
  static void print_token (yytoken_kind_t token, YYSTYPE val);
  static void trace_token (yytoken_kind_t token, YYLTYPE loc);
}

…

这样，不合格的人就实现了 与这两种部分的功能相同，但它是 始终明确您打算哪种类型。而且，这两种总是 即使在没有 .%code top%codePrologue%union

上面的块在逻辑上包含两部分。第一个 警告前的两行需要出现在解析器顶部附近 实现文件。警告后的第一行是必需的，因此也需要出现在解析器实现中 文件。但是，如果您已指示 Bison 生成解析器头文件 （参见 Bison Declaration Summary），您可能希望出现该行 在该头文件中的定义之前也是如此。该定义还应出现在解析器头文件中，以 覆盖那里的默认定义。%code topYYSTYPEYYSTYPEYYLTYPEYYLTYPE

换句话说，在上面的块中，除了前两个之外 行是 AND 定义所需的依赖项代码。 因此，它们属于一个或多个：%code topYYSTYPEYYLTYPE%code requires

%code top {
  #define _GNU_SOURCE
  #include <stdio.h>
}

%code requires {
  #include "ptypes.h"
}

%union {
  long n;
  tree t;  /* tree is defined in ptypes.h. */
}

%code requires {
  #define YYLTYPE YYLTYPE
  typedef struct YYLTYPE
  {
    int first_line;
    int first_column;
    int last_line;
    int last_column;
    char *filename;
  } YYLTYPE;
}

%code {
  static void print_token (yytoken_kind_t token, YYSTYPE val);
  static void trace_token (yytoken_kind_t token, YYLTYPE loc);
}

…

现在，Bison 将在解析器实现文件和解析器标头的 Bison 生成和定义之前插入新定义 文件。（按照同样的推理，也会是 适合编写自己的定义。#include "ptypes.h"YYLTYPEYYSTYPEYYLTYPE%code requiresYYSTYPE

当你为 和 编写依赖项代码时， 无论如何，您都应该更喜欢 是否指示 Bison 生成解析器头文件。当你是 编写仅需要 Bison 插入解析器的代码 实现文件，并且没有特殊需要出现在 该文件，您应该更喜欢不合格的 .这些做法将使代码的每个块的目的 对 Bison 和其他读取您的语法文件的开发人员来说是明确的。 按照这些做法，我们期望不合格的，并且是四种备选方案中最重要的。YYSTYPEYYLTYPE%code requires%code top%code%code top%code%code requiresPrologue

在开发解析器时的某个时刻，您可能会决定向解析器外部的模块提供。因此，您 可能希望 Bison 将原型插入到两个解析器标头中 文件和解析器实现文件。由于此函数不是 or 需要的依赖关系，它不会使 感觉将其原型移动到 .更重要的是， 因为它依赖于 和 是不够的。相反，将其原型从 不合格：trace_tokenYYSTYPEYYLTYPE%code requiresYYLTYPEyytoken_kind_t%code requires%code%code provides

%code top {
  #define _GNU_SOURCE
  #include <stdio.h>
}

%code requires {
  #include "ptypes.h"
}

%union {
  long n;
  tree t;  /* tree is defined in ptypes.h. */
}

%code requires {
  #define YYLTYPE YYLTYPE
  typedef struct YYLTYPE
  {
    int first_line;
    int first_column;
    int last_line;
    int last_column;
    char *filename;
  } YYLTYPE;
}

%code provides {
  void trace_token (yytoken_kind_t token, YYLTYPE loc);
}

%code {
  static void print_token (FILE *file, int token, YYSTYPE val);
}

…

Bison 会将原型插入到两个解析器中 头文件和 、 和 的定义之后的解析器实现文件。trace_tokenyytoken_kind_tYYLTYPEYYSTYPE

上面的示例小心翼翼地按照以下顺序编写指令： 生成的解析器实现和头文件的布局：、 、 和 。虽然您的语法文件通常可能更容易阅读，但如果 你也遵循这个顺序，野牛不需要它。取而代之的是，Bison 让 你选择一个对你有意义的组织。%code top%code requires%code provides%code

您可以在语法文件中多次声明这些指令中的任何一个。 在这种情况下，Bison 按声明顺序连接包含的代码。 这是这些指令之一的位置在 语法文件会影响其功能。

前两个属性的结果是，您可以更灵活地处理 整理语法文件。 例如，您可以按语义组织与语义类型相关的指令 类型：

%code requires { #include "type1.h" }
%union { type1 field1; }
%destructor { type1_free ($$); } <field1>
%printer { type1_print (yyo, $$); } <field1>

%code requires { #include "type2.h" }
%union { type2 field2; }
%destructor { type2_free ($$); } <field2>
%printer { type2_print (yyo, $$); } <field2>

您甚至可以将上述每个指令组放在 使用关联语义的规则集旁边的语法文件 类型。 （在规则部分中，您必须用 分号。 而且您不必担心 定义部分将对其功能产生不利影响 违反直觉的方式，只是因为它是第一位的。 使用部分是不可能的。%unionPrologue

本节关注的是解释四种备选方案相对于原始 Yacc 的优势。 但是，在大多数情况下，使用这些指令时，您不需要 考虑一下这里讨论的所有低级排序问题。 相反，您应该简单地使用这些指令来标记 根据其目的进行编码，并让 Bison 处理排序。 是最通用的标签。 根据需要将代码移动到 、 或 。ProloguePrologue%code%code requires%code provides%code top

3.1.3 野牛申报部分

该部分包含定义 终端符号和非终端符号，指定优先级，依此类推。 在一些简单的语法中，您可能不需要任何声明。 见野牛宣言。Bison declarations

3.1.4 语法规则部分

语法规则部分包含一个或多个 Bison 语法 规则，仅此而已。请参阅语法规则。

必须始终至少有一个语法规则，并且第一个 ''（在语法规则之前）甚至永远不会被省略 如果它是文件中的第一件事。%%

3.1.5 结语

被逐字复制到解析器的末尾 实现文件，就像复制到 开始。这是放置任何东西的最方便的地方 希望在解析器实现文件中拥有，但不需要 在定义之前。例如，定义 的，经常去这里。因为 C 需要 函数在使用前要声明，通常需要声明 功能类似于序幕，甚至 如果您在结语中定义它们。请参阅分析器 C 语言接口。EpiloguePrologueyyparseyylexyyerroryylexyyerror

如果最后一部分是空的，您可以省略分隔它的“” 从语法规则。%%

Bison 解析器本身包含许多宏和标识符，其名称 以“”或“”开头，因此最好避免使用 结语中的任何此类名称（本手册中记录的名称除外） 语法文件。yyYY

3.3.1 语法规则的语法

Bison 语法规则具有以下一般形式：

result: components…;

其中 是此规则描述的非终端符号， 并且是各种终端和非终端符号 由此规则组合在一起（请参阅符号、终端和非终端）。resultcomponents

例如

exp: exp '+' exp;

表示两个类型的分组，中间有一个 '' 标记， 可以组合成一个更大的类型分组。exp+exp

规则中的空白仅对分隔符号有意义。您可以添加 随心所欲地增加空白。

分散在组件之间可以确定 规则的语义。操作如下所示：actions

{C statements}

这是支撑代码的一个示例，即 C 代码被 大括号，很像 C 语言中的复合语句。 任何 C 标记序列，只要其大括号是平衡的。野牛 不直接检查支撑代码的正确性;它只是 将代码复制到解析器实现文件，其中 C 编译器可以检查它。

在大括号代码中，平衡大括号计数不受大括号的影响 在注释、字符串文本或字符常量中，但它是 受 C 二元字母 '' 和 '' 的影响，它们表示 括号。在顶层，支撑代码必须以 '' 结尾 而不是通过二分法。野牛不寻找三元组，所以如果支撑 代码使用三元图，应确保它们不会影响 大括号的嵌套或注释的边界、字符串文字或 字符常量。<%%>}

通常只有一个动作，它遵循组件。 请参阅操作。

同一的多个规则可以单独编写，也可以 与竖线字符 '' 连接，如下所示：result|

result:
  rule1-components…
| rule2-components…
…
;

即使以这种方式连接，它们仍然被认为是不同的规则。

3.3.2 空规则

如果规则的右侧 （） 为空。这意味着在前面的示例中可以匹配 空字符串。再举一个例子，下面是如何定义一个可选的 分号：componentsresult

semicolon.opt: | ";";

很容易看不到空规则，尤其是在使用时。该指令允许明确规则为 目的：|%empty

semicolon.opt:
  %empty
| ";"
;

标记非空规则是错误的。如果使用 运行，则将报告没有 的空规则。除非指定，否则使用将启用此警告。%empty-Wempty-rulebison%empty%empty-Wno-empty-rule

该指令是 Bison 扩展，它不适用于 雅克。为了保持与 POSIX Yacc 的兼容性，习惯上将 注释 '' 在每个没有组件的规则中：%empty/* empty */

semicolon.opt:
  /* empty */
| ";"
;

3.3.3 递归规则

当规则的非终端时，规则称为递归规则 也出现在它的右手边。几乎所有的 Bison 语法都需要 使用递归，因为这是定义任何 特定事物的数字。考虑这个递归定义 一个或多个表达式的逗号分隔序列：result

expseq1:
  exp
| expseq1 ',' exp
;

由于递归使用 是 中最左边的符号 右手边，我们称之为左递归。相比之下，这里 使用右递归定义相同的构造：expseq1

expseq1:
  exp
| exp ',' expseq1
;

任何类型的序列都可以使用左递归或右递归来定义 递归，但你应该始终使用左递归，因为它可以 解析具有有限堆栈空间的任意数量元素的序列。 右递归占用 Bison 堆栈上的空间与 序列中的元素数，因为所有元素都必须 在规则应用一次之前就转移到堆栈上。 有关进一步的解释，请参阅 Bison 解析器算法 这个。

间接递归或相互递归发生在以下结果 规则不会直接出现在其右侧，但确实会出现 在右侧出现的其他非终端的规则中 边。

例如：

expr:
  primary
| primary '+' primary
;

primary:
  constant
| '(' expr ')'
;

定义了两个相互递归的非终端，因为每个都引用 其他。

3.4.1 语义值的数据类型

在一个简单的程序中，使用相同的数据类型可能就足够了 所有语言结构的语义值。在 RPN 和中缀计算器示例（请参阅反向波兰符号计算器）。

Bison 通常使用该类型作为语义值，如果您的程序 对所有语言构造使用相同的数据类型。指定一些其他 类型，如下定义变量：int%defineapi.value.type

%define api.value.type {double}

或

%define api.value.type {struct semantic_value_type}

的值应为不 包含括号或方括号。api.value.type

或者，在 C 语言中，不要依赖 Bison 的支持， 您可以依赖 C 预处理器并定义为宏：%defineYYSTYPE

#define YYSTYPE double

此宏定义必须放在语法文件的序言中 （见野牛语法大纲）。如果与 POSIX Yacc 的兼容性对您很重要， 使用这个。但请注意，Bison 无法知道 的值，而不是 即使它是否被定义，所以它无法提供服务。 此外，这仅适用于 C。YYSTYPE

3.4.2 多个值类型

在大多数程序中，不同类型的数据需要不同的数据类型 的令牌和分组。例如，数值常量可能需要 type or ，而字符串常量需要 type ，标识符可能需要指向 符号表。intlongchar *

要在一个解析器中对语义值使用多种数据类型，Bison 要求你做两件事：

• 指定可能数据类型的整个集合。有几个 选项：
  • 让 Bison 根据您分配给符号的标签计算并集类型;
  • 使用野牛宣言（见《联合宣言》%union);
  • 将变量定义为并集类型 其成员是类型标记（请参阅提供结构化语义值类型%defineapi.value.type);
  • 使用 a 或 a 定义为 其成员名称是类型标记的联合类型。typedef#defineYYSTYPE
• 为每个符号（终端或非终端）选择其中一种类型 使用哪些语义值。这是针对具有 Bison 声明的令牌（请参阅令牌种类名称）和 用于使用 / Bison 声明的分组 （请参阅非终端符号）。%token%nterm%type

3.4.3 生成语义值类型

变量的特殊值指示 Bison 类型标签（与 和 指令一起使用）是真正的类型， 不是 的成员姓名。union%defineapi.value.type%token%nterm%typeYYSTYPE

例如：

%define api.value.type union
%token <int> INT "integer"
%token <int> 'n'
%nterm <int> expr
%token <char const *> ID "identifier"

生成适当的值以支持每个交易品种 类型。令牌的成员名称比具有 声明的标识符（例如 和 以上，但 不是 ） 是 。其他符号未指定 您不应该依赖的名称;而是依靠 C 强制转换来访问 具有适当类型的语义值：YYSTYPEYYSTYPEidINTID'n'id

/* For an "integer". */
yylval.INT = 42;
return INT;

/* For an 'n', also declared as int. */
*((int*)&yylval) = 42;
return 'n';

/* For an "identifier". */
yylval.ID = "42";
return ID;

如果定义了变量 （参见 %define Summary），则它也用于前缀 工会成员姓名。例如，使用 ''：%defineapi.token.prefix%define api.token.prefix {TOK_}

/* For an "integer". */
yylval.TOK_INT = 42;
return TOK_INT;

如果启用了 （或 /），则此 Bison 扩展无法工作，因为 POSIX 要求 Yacc 将标记生成为宏（例如，“'”或“'”）。%yacc-y--yacc#define INT 258#define TOK_INT 258

为 C++ 提供了类似的功能，该功能还克服了 C++ 限制（禁止非平凡对象成为 A 的一部分）： ''，请参阅 C++ 变体。union%define api.value.type variant

3.4.4 《联盟宣言》

该声明指定了可能的整个集合 语义值的数据类型。关键字后跟 支撑代码包含与 C 中 a 相同的内容。%union%unionunion

例如：

%union {
  double val;
  symrec *tptr;
}

这表示两种替代类型是 和 。他们被赋予了名字和 ;使用这些名称 在 和 声明中选择 终端符号或非终端符号的类型之一（请参阅非终端符号）。doublesymrec *valtptr%token%nterm%type

作为 POSIX 的扩展，允许在 .为 例：%union

%union value {
  double val;
  symrec *tptr;
}

指定 union 标签，因此对应的 C 类型为 。如果未指定标记，则默认为 （请参阅 %define Summary）。valueunion valueYYSTYPE

作为 POSIX 的另一个扩展，您可以指定多个声明;它们的内容是串联的。但是，只有第一个声明可以指定标记。%union%union

请注意，与在 C 中进行声明不同，您不需要编写 右大括号后的分号。union

3.4.5 提供结构化的语义值类型

如果您的语法至少包含一个 '' ，则可以定义和使用自己的联合类型，而不是 标记。例如，您可以将以下内容放入头文件中：%unionYYSTYPE<type>parser.h

union YYSTYPE {
  double val;
  symrec *tptr;
};

然后你的语法可以使用以下内容来代替：%union

%{
#include "parser.h"
%}
%define api.value.type {union YYSTYPE}
%nterm <val> expr
%token <tptr> ID

实际上，您也可以提供一个相当的， 如果您想跟踪每个符号的信息（例如 如前所述）。structunion

您提供的类型甚至可以是结构化的，并包含指针，其中 案例 您提供的类型标签可能是复合的，带有 '' 和 '' 运营商。.->

3.4.6 操作

操作附带语法规则，并包含要执行的 C 代码 每次识别该规则的实例时。大多数操作的任务 是计算由规则构建的分组的语义值，从 与标记或较小分组关联的语义值。

操作由包含 C 语句的支撑代码组成，可以是 放置在规则中的任何位置; 它在该位置执行。大多数规则在 规则的末尾，跟随所有组件。中间的动作 规则很棘手，仅用于特殊目的（请参阅 Midrule 中的操作）。

动作中的 C 代码可以引用 规则与构造匹配的组件， 它代表第 th 个组件的值。语义 正在构造的分组的值为 。另外 符号的语义值可以通过命名 引用构造或 . Bison 将这两种结构都转化为 将操作复制到分析器中的适当类型 实现文件。 （或者，当它站立时 对于当前分组）被转换为可修改的左值，因此它 可以分配给。$nn$$$name$[name]$$$name

下面是一个典型的例子：

exp:
…
| exp '+' exp     { $$ = $1 + $3; }

或者，就命名引用而言：

exp[result]:
…
| exp[left] '+' exp[right]  { $result = $left + $right; }

此规则从两个较小的分组构造一个 通过加号令牌连接。在动作中，和 （ 和 ） 参考两个组件分组的语义值， 这是规则右侧的第一个和第三个符号。 总和存储在 （） 中，因此它变为 语义值 规则刚刚识别的加法表达式。如果有一个 与“”标记关联的有用语义值，它可以是 称为 .expexp$1$3$left$rightexp$$$result+$2

有关使用命名引用的详细信息，请参阅命名引用 引用构造。

请注意，竖线字符“”实际上是一条规则 分隔符，操作附加到单个规则。这是一个 与 Flex 等工具的区别，其中 '' 代表任一 “或”或“与下一条规则相同的操作”。在 以下示例，仅当找到“”时才会触发该操作：||b

a-or-b: 'a'|'b'   { a_or_b_found = 1; };

如果未为规则指定操作，则 Bison 会提供默认值：.因此，规则中第一个符号的值 成为整个规则的值。当然，默认操作是 仅当两种数据类型匹配时才有效。没有有意义的默认值 空规则的操作;每个空规则都必须有一个显式操作 除非规则的值无关紧要。$$ = $1

$n允许使用零或负作为参考 到堆栈上的令牌和分组，然后与 当前规则。这是一种非常冒险的做法，并且要可靠地使用它 您必须确定应用规则的上下文。这里 是您可以可靠地使用它的情况：n

foo:
  expr bar '+' expr  { … }
| expr bar '-' expr  { … }
;

bar:
  %empty    { previous_expr = $0; }
;

只要仅以此处显示的方式使用，则始终指 的定义。bar$0exprbarfoo

如果满足以下条件，还可以访问前瞻令牌的语义值 any，来自语义操作。 此语义值存储在 中。 请参阅在操作中使用的特殊功能。yylval

3.4.7 操作中值的数据类型

如果为语义值选择了单一数据类型，则 and 构造始终具有该数据类型。$$$n

如果您曾经指定过各种数据类型，那么 必须为每个终端或非终端声明这些类型中的选择 可以具有语义值的符号。然后，每次使用 or 时，其数据类型由它引用的符号决定 在规则中。在此示例中，%union$$$n

exp:
  …
| exp '+' exp    { $$ = $1 + $3; }

$1并引用 的实例，所以它们都 为非终端符号声明数据类型。如果使用，它将为 终端符号，不管它是什么。$3expexp$2'+'

或者，您可以在引用值时指定数据类型， 通过在开头的“”之后插入“” 参考。例如，如果已定义类型，如下所示：<type>$

%union {
  int itype;
  double dtype;
}

然后你可以写来引用 规则为整数，或将其称为双精度。$<itype>1$<dtype>1

3.4.8 Midrule 中的操作

有时，将操作放在规则的中间很有用。 这些操作的编写方式与通常的规则结束操作类似，但它们 在解析器识别以下组件之前执行。

• 使用中间规则操作
• 类型化中间线操作
• Midrule 动作翻译
• 由于 Midrule 操作引起的冲突

stmt:
  "let" '(' var ')'
    {
      $<context>$ = push_context ();
      declare_variable ($3);
    }
  stmt
    {
      $$ = $6;
      pop_context ($<context>5);
    }

stmt:
  "let" '(' var ')'
    {
      $<context>let = push_context ();
      declare_variable ($3);
    }[let]
  stmt
    {
      $$ = $6;
      pop_context ($<context>let);
    }

stmt:
  "let" '(' var ')'
    {
      $<context>$ = push_context (); // ***
      declare_variable ($3);
    }
  stmt
    {
      $$ = $6;
      pop_context ($<context>5);     // ***
    }

stmt:
  "let" '(' var ')'
    <context>{                       // ***
      $$ = push_context ();          // ***
      declare_variable ($3);
    }
  stmt
    {
      $$ = $6;
      pop_context ($5);              // ***
    }

exp: { a(); } "b" { c(); } { d(); } "e" { f(); };

$@1: %empty { a(); };
$@2: %empty { c(); };
$@3: %empty { d(); };
exp: $@1 "b" $@2 $@3 "e" { f(); };

exp: { a(); } "b" { $$ = c(); } { d(); } "e" { f = $1; };

@1: %empty { a(); };
@2: %empty { $$ = c(); };
$@3: %empty { d(); };
exp: @1 "b" @2 $@3 "e" { f = $1; }

$ bison -Wmidrule-value mid.y

mid.y:2.6-13: warning: unset value: $$
    2 | exp: { a(); } "b" { $$ = c(); } { d(); } "e" { f = $1; };
      |      ^~~~~~~~

mid.y:2.19-31: warning: unused value: $3
    2 | exp: { a(); } "b" { $$ = c(); } { d(); } "e" { f = $1; };
      |                   ^~~~~~~~~~~~~

%nterm <context> let
%destructor { pop_context ($$); } let
%printer { print_context (yyo, $$); } let

%%

stmt:
  let stmt
    {
      $$ = $2;
      pop_context ($let);
    };

let:
  "let" '(' var ')'
    {
      $let = push_context ();
      declare_variable ($var);
    };

compound:
  '{' declarations statements '}'
| '{' statements '}'
;

compound:
  { prepare_for_local_variables (); }
     '{' declarations statements '}'

|    '{' statements '}'
;

compound:
  { prepare_for_local_variables (); }
    '{' declarations statements '}'
| { prepare_for_local_variables (); }
    '{' statements '}'
;

compound:
  '{' { prepare_for_local_variables (); }
    declarations statements '}'
| '{' statements '}'
;

subroutine:
  %empty  { prepare_for_local_variables (); }
;

compound:
  subroutine '{' declarations statements '}'
| subroutine '{' statements '}'
;

3.5.1 位置的数据类型

为位置定义数据类型比为语义值定义数据类型要简单得多。 因为所有标记和分组始终使用相同的类型。位置类型 使用 ''：%define api.location.type

%define api.location.type {location_t}

这在 C 生成的代码中定义了类型名称。未定义时，Bison 使用具有四个的默认结构类型 成员：YYLTYPEYYLTYPE

typedef struct YYLTYPE
{
  int first_line;
  int first_column;
  int last_line;
  int last_column;
} YYLTYPE;

在 C 中，您还可以通过定义一个名为 的宏来指定位置类型，就像您可以通过定义 宏（请参阅语义值的数据类型）。但是，而不是使用 宏，我们推荐 AND 变量。YYLTYPEYYSTYPEapi.value.typeapi.location.type%define

默认位置表示源文件中的一个范围，但这不是一个 要求。它可以是一个点，也可以只是一个行号，甚至更多 结构复杂。

使用默认位置类型时，Bison 将初始化所有这些字段 在解析开始时设置为 1。使用自定义位置类型进行初始化（或选择其他位置类型 initialization），使用指令。请参阅在解析之前执行操作。yyllocyylloc%initial-action

3.5.2 操作和位置

操作不仅对定义语言语义有用，而且对 使用位置描述输出解析器的行为。

构建句法分组位置的最明显方法是非常 类似于语义值的计算方式。在给定的规则中，几个 构造可用于访问正在匹配的元素的位置。 右侧的第 个分量的位置是 ，而左侧分组的位置是 。n@n@$

此外，命名引用构造符号位置，也可用于寻址符号位置。 有关使用命名引用的详细信息，请参阅命名引用 引用构造。@name@[name]

下面是使用位置默认数据类型的基本示例：

exp:
  …
| exp '/' exp
    {
      @$.first_column = @1.first_column;
      @$.first_line = @1.first_line;
      @$.last_column = @3.last_column;
      @$.last_line = @3.last_line;
      if ($3)
        $$ = $1 / $3;
      else
        {
          $$ = 1;
          fprintf (stderr, "%d.%d-%d.%d: division by zero",
                   @3.first_line, @3.first_column,
                   @3.last_line, @3.last_column);
        }
    }

至于语义值，位置有一个默认操作，即 每次匹配规则时运行。它将 的开头设置为 第一个符号的开头，以及 的结尾 最后一个符号。@$@$

使用此默认操作，位置跟踪可以全自动。这 上面的例子只是这样重写：

exp:
  …
| exp '/' exp
    {
      if ($3)
        $$ = $1 / $3;
      else
        {
          $$ = 1;
          fprintf (stderr, "%d.%d-%d.%d: division by zero",
                   @3.first_line, @3.first_column,
                   @3.last_line, @3.last_column);
        }
    }

也可以访问前瞻令牌的位置（如果有）， 从语义操作。 此位置存储在 中。 请参阅在操作中使用的特殊功能。yylloc

3.5.3 打印位置

使用默认位置类型时，调试跟踪报告符号的 位置。生成的解析器使用宏执行此操作。YYLOCATION_PRINT

宏：YYLOCATION_PRINT（文件、位置）; ¶

启用跟踪后，在（类型为“”）上打印（类型为“”）。禁用跟踪时不执行任何操作，或者 如果位置类型是用户定义的。locYYLTYPE const *fileFILE *

要使用用户定义的位置类型获取调试跟踪中的位置， 定义宏。例如：YYLOCATION_PRINT

#define YYLOCATION_PRINT   location_print

3.5.4 位置的默认操作

实际上，操作并不是计算位置的最佳位置。因为 位置比语义值要普遍得多，在 输出解析器，用于重新定义要为每个执行的默认操作 统治。每次规则 匹配，然后运行关联的操作。它也被调用 在处理语法错误时，计算错误的位置。 在报告无法解决的句法歧义之前，GLR 解析器以递归方式调用以计算位置 这种模棱两可。YYLLOC_DEFAULTYYLLOC_DEFAULT

大多数情况下，此宏足够通用，可以抑制位置 来自语义操作的专用代码。

宏采用三个参数。第一个是 分组的位置（计算结果）。当一个 规则匹配，则第二个参数标识 规则的所有右侧元素都匹配，以及第三个 参数是规则右侧的大小。 当 GLR 解析器报告歧义时，哪个候选者 它传递到的右侧未定义。 处理语法错误时，第二个参数标识位置 在错误处理过程中丢弃的符号，以及第三个 参数是丢弃的符号数。YYLLOC_DEFAULTYYLLOC_DEFAULT

默认情况下，是这样定义的：YYLLOC_DEFAULT

# define YYLLOC_DEFAULT(Cur, Rhs, N)                      \
do                                                        \
  if (N)                                                  \
    {                                                     \
      (Cur).first_line   = YYRHSLOC(Rhs, 1).first_line;   \
      (Cur).first_column = YYRHSLOC(Rhs, 1).first_column; \
      (Cur).last_line    = YYRHSLOC(Rhs, N).last_line;    \
      (Cur).last_column  = YYRHSLOC(Rhs, N).last_column;  \
    }                                                     \
  else                                                    \
    {                                                     \
      (Cur).first_line   = (Cur).last_line   =            \
        YYRHSLOC(Rhs, 0).last_line;                       \
      (Cur).first_column = (Cur).last_column =            \
        YYRHSLOC(Rhs, 0).last_column;                     \
    }                                                     \
while (0)

其中 是第 个符号的位置 in when 为正数，以及符号的位置 就在还原之前，当 和 都为零。YYRHSLOC (rhs, k)krhskkn

在定义时，应考虑：YYLLOC_DEFAULT

• 所有参数都没有副作用。但是，只有第一个（ result） 应由 修改。YYLLOC_DEFAULT
• 为了与语义操作保持一致，在 右侧范围从 1 到 。当为零时，只有 0 是 有效索引，它指的是减少之前的符号。 在错误处理期间始终为正数。nnn
• 如果需要，您的宏应该将其参数括起来，因为 实际参数可能不会用括号括起来。此外，您的 宏应该扩展为可以用作单个的东西 语句后跟分号。

3.7.1 需要 Bison 的版本

您可能需要 Bison 的最低版本来处理语法。如果 未满足要求，退出并显示错误（退出 状态 63）。bison

%require "version"

某些已弃用的行为被禁用，某些行为需要：version

“3.2”（或更高）

C++ 已弃用的文件和 否 生成时间更长。position.hhstack.hh

3.7.2 代币种类名称

声明令牌种类名称（终端符号）的基本方法如下：

%token name

Bison 会将其转换为解析器中的定义，以便 函数（如果它在此文件中）可以使用名称来 代表这种令牌类型的代码。yylexname

或者，您可以使用 、 、 、 或者代替 ，如果要指定 关联性和优先级。请参阅运算符优先级。但是，对于 为了清楚起见，我们建议仅使用这些指令来声明关联性 和优先级，而不是添加字符串别名、语义类型等。%left%right%precedence%nonassoc%token

您可以通过附加 非负十进制或十六进制整数值立即出现在字段中 在令牌名称之后：

%token NUM 300
%token XNUM 0x12d // a GNU extension

然而，通常最好让 Bison 为所有人选择数字代码 令牌种类。Bison 将自动选择与 彼此之间或与普通字符。

如果堆栈类型是联合，则必须扩充 或其他令牌声明以包含数据类型 用尖括号分隔的备选方案（请参阅多个值类型）。%token

例如：

%union {              /* define stack type */
  double val;
  symrec *tptr;
}
%token <val> NUM      /* define token NUM and its type */

您可以通过编写 声明末尾的文字字符串，声明 名称。例如：%token

%token ARROW "=>"

例如，C 语言的语法可能使用 等效的文字字符串标记：

%token  <operator>  OR      "||"
%token  <operator>  LE 134  "<="
%left  OR  "<="

将文本字符串和令牌种类名称等同起来后，就可以使用它们了 在进一步的声明或语法规则中可互换。该函数可以使用令牌名称或文本字符串来获取 令牌种类代码（请参阅 yylex 的调用约定）。yylex

字符串别名允许使用文本字符串提供更好的错误消息 而不是令牌名称，例如“”而不是“”。syntax error, unexpected ||, expecting number or (syntax error, unexpected OR, expecting NUM or LPAREN

字符串别名也可以标记为国际化（请参阅令牌国际化）：

%token
    OR     "||"
    LPAREN "("
    RPAREN ")"
    '\n'   _("end of line")
  <double>
    NUM    _("number")

将用法语“”而不是“”产生。erreur de syntaxe, || inattendu, attendait nombre ou (erreur de syntaxe, || inattendu, attendait number ou (

3.7.3 运算符优先级

使用 、 、 或 声明声明 标记并指定其优先级和关联性， 一下子。这些称为优先级声明。 有关运算符的一般信息，请参阅运算符优先级 优先。%left%right%nonassoc%precedence

优先级声明的语法与以下语句几乎相同：%token

%left symbols…

或

%left <type> symbols…

事实上，这些声明中的任何一项都服务于 . 但除此之外，它们还指定了 所有 ：%tokensymbols

• 运算符的关联性决定了如何重复使用 运算符 nest：是否 '' 通过与 First 分组或与 First 分组来解析。 指定左关联性（与 First 分组）并指定右关联性 （与第一分组）。 指定 否 关联性，这意味着“”被视为语法错误。opx op y op zxyyz%leftxy%rightyz%nonassocx op y op z

  %precedence仅赋予 的优先级，并定义 完全没有关联性。使用它仅定义优先级，并保留任何 启用了由于关联性而导致的潜在冲突。symbols

• 运算符的优先级决定了它如何与其他运算符嵌套。 在单个优先级声明中声明的所有令牌都相等 优先级和嵌套根据它们的关联性。当两个 在不同的优先级声明中声明的令牌关联，一个 稍后声明的优先级更高，并首先分组。

为了向后兼容，两者之间存在令人困惑的差异 参数列表和优先级声明。只有 a 可以将文本字符串与标记类型名称相关联。一个 precedence 声明始终将文本字符串解释为对 一个单独的令牌。例如：%token%token

%left  OR "<="         // Does not declare an alias.
%left  OR 134 "<=" 135 // Declares 134 for OR and 135 for "<=".

3.7.4 非终端符号

用于指定多个值类型时，必须 声明每个非终端符号的值类型，其值为 使用。这是通过声明完成的，如下所示：%union%type

%type <type> nonterminal…

下面是一个非终端符号的名称，并且是您想要的替代符号中给出的名称 （见《联盟宣言》）。您可以在 如果它们具有相同的值类型，则声明相同。使用空间 分隔符号名称。nonterminaltype%union%type

虽然 POSIX Yacc 只允许非终端，但 Bison 接受 该指令也适用于终端符号。声明 专为非终端符号，使用更安全的：%type%nterm

%nterm <type> nonterminal…

3.7.5 符号声明的语法

用于声明符号的各种指令的语法如下。

%token tag? ( id number? string? )+ ( tag ( id number? string? )+ )*
%left  tag? ( id number?)+ ( tag ( id number? )+ )*
%type  tag? ( id | char | string )+ ( tag ( id | char | string )+ )*
%nterm tag? id+ ( tag id+ )*

其中表示类型标记，例如“”，表示 标识符，例如“”、十进制或十六进制 整数，例如“”或“”，字符文字 例如 ''，以及字符串文本，例如 ‘’.后缀量词是 ''（零或一）， ''（零或更多）和 ''（一个或多个）。tag<ival>idNUMnumber3000x12dchar'+'string"number"?*+

指令 ，并表现 喜欢。%precedence%right%nonassoc%left

3.7.6 解析前执行操作

有时，解析器需要在解析之前执行一些初始化。 该指令允许此类任意代码。%initial-action

指令： %initial-action { code } ¶

声明在每次调用解析之前必须调用 braced。可以使用（或）和 — 的初始值和位置 展望未来 — 以及 .codeyyparsecode$$$<tag>$@$%parse-param

例如，如果您的位置使用文件名，则可以使用

%parse-param { char const *file_name };
%initial-action
{
  @$.initialize (file_name);
};

3.7.7 释放丢弃的符号

在错误恢复期间（请参阅错误恢复），符号已推送 来自文件其余部分的堆栈和令牌将被丢弃，直到 解析器站起来。如果解析器内存不足，或者如果它 返回 ，或 ，所有 必须丢弃堆栈上的符号。即使解析器成功，它 必须放弃开始符号。YYABORTYYACCEPTYYNOMEM

当丢弃的符号传达基于堆的信息时，此内存是 失去。虽然这种行为对于批处理分析器是可以容忍的，例如 在传统的编译器中，对于像 shell 或 可以无限期解析和执行的协议实现。

该指令定义在以下情况下调用的代码 符号被自动丢弃。%destructor

指令： %destructor { code } 符号 ¶

每当解析器丢弃其中一个 .内 ， （或 ） 指定与丢弃的符号关联的语义值，并指定其位置。其他解析器参数包括 也可用（参见解析器函数 yyparse）。codesymbolscode$$$<tag>$@$

当一个符号列在 中时，它称为 每个符号 。 您还可以通过列出语义类型来定义每个类型 标记。 在这种情况下，解析器将在丢弃任何 具有该语义类型标记的语法符号，除非该符号有自己的 每个符号 。symbols%destructor%destructor%destructorsymbolscode%destructor

最后，您可以定义两种不同类型的默认值。 您可以将每个 和 放在 语法文件中只有一个声明。 每当 丢弃任何没有 per-symbol 和 per-type 的用户定义语法符号。 对于此类语法，解析器使用 for 已正式声明语义类型标记的符号（、、 和 算作此类声明，但不计入此类声明）。 对于此类语法，解析器使用 for 没有声明的语义类型标记的符号。%destructor<*><>symbols%destructorcode%destructorcode<*>%token%nterm%type$<tag>$code<>

例如：

%union { char *string; }
%token <string> STRING1 STRING2
%nterm <string> string1 string2
%union { char character; }
%token <character> CHR
%nterm <character> chr
%token TAGLESS

%destructor { } <character>
%destructor { free ($$); } <*>
%destructor { free ($$); printf ("%d", @$.first_line); } STRING1 string1
%destructor { printf ("Discarding tagless symbol.\n"); } <>

保证，当解析器丢弃任何具有 语义类型标记，它传递其语义值 默认设置为。 但是，当解析器丢弃 a 或 a 时， 它使用第三个，它释放了它和 将其行号打印为 （ 仅调用一次）。 最后，解析器只在丢弃任何符号时打印一条消息， 例如，没有语义类型标签。<character>freeSTRING1string1%destructorstdoutfreeTAGLESS

Bison 生成的解析器仅调用默认的 s 用户定义的符号，而不是 Bison 定义的符号。 例如，解析器不会为特殊的 Bison 定义的符号 、 或（参见 Bison Symbols）调用任何一种默认值。 这些都不能在语法中引用。 它也不会为令牌调用（参见 Bison 符号），无论您是否 在语法中引用它。 但是，如果满足以下条件，它可能会为结束令牌（令牌 0）调用其中之一 将其从 to 重新定义，例如：%destructor%destructor$accept$undefined$enderror$endEND

%token END 0

最后，Bison 永远不会为未引用的 midrule 语义值（请参阅 Midrule 中的操作）。 也就是说，Bison 不认为中间线具有语义值，如果你 不要在中间线的操作中引用，或者（其中是中间线的右侧符号位置）在 该规则中的任何后续操作。但是，如果您确实引用了其中任何一个，则 Bison 生成的解析器将调用 它丢弃中间线符号。%destructor$$$nn<>%destructor

丢弃的符号如下：

• 在错误恢复的第一阶段弹出的堆叠符号，
• 错误恢复第二阶段的传入终端，
• 当前展望和整个堆栈（当前 右侧符号）时，解析器立即返回，以及
• 当前前瞻和整个堆栈（包括当前右侧 侧符号）当 C++ 解析器 （） 捕获 中的异常时，lalr1.ccparse
• 开始符号，当解析器成功时。

由于显式调用 、 或 错误恢复失败，解析器可以立即返回 或记忆力耗尽。YYABORTYYACCEPTYYNOMEM

显式触发语法的规则的右侧符号 错误过孔不会自动丢弃。通常 根据经验，只有当用户操作无法管理时，才会调用析构函数 记忆。YYERROR

3.7.8 打印语义值

启用运行时跟踪后（请参阅跟踪解析器）， 解析器报告其操作，例如减少。当涉及符号时 在报告操作时，仅显示其类型，因为解析器不能 了解语义值的格式。

该指令定义当符号 报道。它的语法与（请参阅释放丢弃的符号）相同。%printer%destructor

指令： %printer { code } 符号 ¶

每当解析器显示 .其中 表示输出流（C 中的 a、C++ 中的 an 和 D），（或 ）指定与 符号及其位置。其他解析器参数包括 也可用（参见解析器函数 yyparse）。codesymbolscodeyyoFILE*std::ostream&stdout$$$<tag>$@$

它们被定义为 for （参见 Freeing Discarded Symbols.）：它们可以是每个类型（例如， ''）、每个符号（例如，''、''、''）、 按默认键入（即 ''），或未按默认键类型（即 ‘’).symbols%destructor<ival>expNUM"float"<*><>

例如：

%union { char *string; }
%token <string> STRING1 STRING2
%nterm <string> string1 string2
%union { char character; }
%token <character> CHR
%nterm <character> chr
%token TAGLESS

%printer { fprintf (yyo, "'%c'", $$); } <character>
%printer { fprintf (yyo, "&%p", $$); } <*>
%printer { fprintf (yyo, "\"%s\"", $$); } STRING1 string1
%printer { fprintf (yyo, "<>"); } <>

保证，当解析器打印任何具有语义类型的符号时 标记，它显示语义的地址 值。但是，当解析器显示 a 或 a 时，它会将其格式化为双引号中的字符串。它执行 在这种情况下只有第二个，所以它只打印一次。 最后，解析器为任何符号打印 ''，例如 没有语义类型标记。有关完整示例，请参阅为 mfcalc 启用调试跟踪。<character>STRING1string1%printer<>TAGLESS

3.7.9 禁止冲突警告

Bison 通常会在语法中出现任何冲突时发出警告 （参见 Shift/Reduce Conflicts），但大多数真正的语法 具有无害的转移/减少冲突，这些冲突在可预测的范围内得到解决 方式，并且很难消除。最好抑制 关于这些冲突的警告，除非冲突的数量 变化。您可以使用声明执行此操作。%expect

声明如下所示：

%expect n

这是一个十进制整数。宣言说应该有 是转移/减少冲突，没有减少/减少冲突。 如果 shift/reduce 冲突的数量不同，Bison 会报告错误 from ，或者如果存在任何 reduce/reduce 冲突。nnn

对于确定性解析器，reduce/reduce 冲突更多 严重，应完全消除。Bison 将始终报告 减少/减少这些分析器的冲突。使用 GLR 然而，解析器，这两种冲突都是例行公事;否则 无需使用 GLR 解析。因此，它是 还可以指定预期的减少/减少冲突数量 在 GLR 解析器中，使用声明：

%expect-rr n

您可能希望在您的 预期冲突的规范。为此，您还可以将修饰符附加到各个规则。 这些修饰符的解释与它们的用法不同 声明。当附加到规则时，它们指示状态数 其中规则涉及冲突。您需要咨询 用于确定要使用的适当数字的输出。 例如，对于以下语法片段，第一个规则出现在两个状态中，其中“”标记是 展望未来。确定这一点后，您可以使用修饰符记录此事实，如下所示：%expect%expect-rr-vempty_dims[%expect

dims:
  empty_dims
| '[' expr ']' dims
;

empty_dims:
  %empty   %expect 2
| empty_dims '[' ']'
;

中间规则操作会生成隐式规则，这些规则也会发生冲突 （请参阅由于 Midrule 操作导致的冲突）。附加 对隐式 中间规则操作的规则，放在操作之前。例如%expect%expect-rr

%glr-parser
%expect-rr 1

%%

clause:
  "condition" %expect-rr 1 { value_mode(); } '(' exprs ')'
| "condition" %expect-rr 1 { class_mode(); } '(' types ')'
;

在这里，适当的中间规则操作要等到之后才能确定 '' 令牌被移动。因此 这两个行动将相互冲突，我们应该期待一个 减少/减少每个冲突。(

通常，使用涉及以下步骤：%expect

• 编译你的语法时没有 .使用该选项 获取冲突发生位置的详细列表。野牛也将 打印冲突数。%expect-v
• 检查每个冲突以确保 Bison 的默认 分辨率是你真正想要的。如果没有，请重写语法和 回到起点。
• 添加声明，从 野牛打印的数字。使用 GLR 解析器，还可以添加声明。%expectn%expect-rr
• （可选）计算一个或多个状态的数目 将显示特定规则的冲突减少，并将这些数字相加 将受影响的规则设置为 AS 或修饰符 视情况而定。冲突的规则将显示在输出列表中 用方括号括起来，或者在减少/减少冲突的情况下， 作为与方括号具有相同前瞻符号的缩减 在相同状态下还原。%expect-rr%expect

现在，如果您引入意外冲突，Bison 将报告错误， 但否则会保持沉默。

3.7.10 开始符号

默认情况下，Bison 假定语法的起始符号是第一个 语法规范部分中指定的非终端。程序员 可以使用以下声明覆盖此限制：%start

%start symbol

3.7.11 纯（重入）解析器

重入计划是一个在以下过程中不会改变的计划 执行;换句话说，它完全由纯（只读）组成 法典。只要可以异步执行，重入就很重要; 例如，非重入程序可能无法安全地从信号调用 处理器。在具有多个控制线程的系统中，非可重入者 程序只能在联锁中调用。

通常，Bison 会生成一个不可重入的解析器。这是 适用于大多数用途，并允许与 Yacc 兼容。（ 标准 Yacc 接口本质上是不可重入的，因为它们使用 静态分配的变量用于与 通信 包括 和 .）yylexyylvalyylloc

或者，您可以生成一个纯的可重入解析器。野牛 声明 '' 表示您希望解析器是 折返。它看起来像这样：%define api.pure

%define api.pure full

结果是通信变量和在 中成为局部变量，并且 调用约定用于词法分析器函数。 有关详细信息，请参阅纯解析器的调用约定。变量在拉取模式下变为本地变量，但在推送模式下变为本地变量。（请参阅错误报告功能 yyerror）。这 调用本身的约定是不变的。yylvalyyllocyyparseyylexyynerrsyyparseyypstateyyparse

解析器是否纯，与语法规则无关。 您可以从任何 有效的语法。

3.7.12 推送解析器

拉取解析器被调用一次，它就会控制，直到其所有输入 完全解析。另一方面，推送解析器称为 每次提供新令牌时。

当推送解析器是 客户端应用程序中的主事件循环。这通常是 当需要触发主事件循环时，对 GUI 的要求 在一定时间段内。

通常，Bison 会生成一个拉取解析器。 以下 Bison 声明说您希望解析器是推送 解析器（参见 %define 摘要）：

%define api.push-pull push

在几乎所有情况下，您都希望确保推送解析器也 纯解析器（请参阅纯（重入）解析器）。唯一的 你应该创建一个不纯的推送解析器的时间是向后 与不纯的 Yacc 拉取模式接口兼容。除非你知道 你在做什么，你的声明应该如下所示：

%define api.pure full
%define api.push-pull push

纯推送解析器之间存在一个显著的功能差异 和不纯的推送解析器。纯推送解析器具有 内存中同时存在许多相同类型的解析器的解析器实例。 不纯的推送解析器一次只能使用一个解析器。

当选择推送解析器时，Bison 将在 生成的解析器。 是生成的结构 解析器用于存储解析器的状态。 是 函数，以创建新的解析器实例。 将释放与相应解析器实例关联的资源。 最后，是每当 令牌可用于提供解析器。一个微不足道的例子 使用纯推送解析器如下所示：yypstateyypstate_newyypstate_deleteyypush_parse

int status;
yypstate *ps = yypstate_new ();
do {
  status = yypush_parse (ps, yylex (), NULL);
} while (status == YYPUSH_MORE);
yypstate_delete (ps);

如果用户决定使用不纯的推送解析器，那么关于 生成的解析器将更改。变量变为全局变量 变量，而不是函数中的局部变量。为 因此，函数的签名更改为 删除令牌作为参数。非重入推送解析器示例将 因此看起来像这样：yycharyypush_parseyypush_parse

extern int yychar;
int status;
yypstate *ps = yypstate_new ();
do {
  yychar = yylex ();
  status = yypush_parse (ps);
} while (status == YYPUSH_MORE);
yypstate_delete (ps);

就是这样。请注意，下一个标记被放入全局变量中，供下次调用该函数使用。yycharyypush_parse

Bison 还支持推送解析器接口和拉取解析器 接口。为了获得此功能， 您应该将 '' 声明替换为 '' 声明。这样做将创建所有 前面提到的符号以及两个额外的符号，以及 . 可以完全像往常一样使用 将被使用。但是，用户应注意，它是在 通过调用生成解析器。 这使得使用 '' 声明比正常函数慢。如果用户 调用函数，它将解析输入的其余部分 流。可以标记以选择子语法 然后是输入流的其余部分。如果你愿意 要在解析样式之间来回切换，您必须 编写自己的函数，知道何时停止查找 用于输入。使用该函数的示例将显示 喜欢这个：%define api.push-pull push%define api.push-pull bothyyparseyypull_parseyyparseyypull_parseyyparse%define api.push-pull bothyyparseyypull_parseyypush_parseyypull_parseyypull_parseyypull_parse

yypstate *ps = yypstate_new ();
yypull_parse (ps); /* Will call the lexer */
yypstate_delete (ps);

添加 '' 声明对 生成的带有 '' 的解析器，就像它所做的那样 ‘’.%define api.pure%define api.push-pull both%define api.push-pull push

3.7.13 野牛声明摘要

以下是用于定义语法的声明的摘要：

指令：%union ¶

声明语义值可能具有的数据类型的集合 （见《联盟宣言》）。

指令：%token ¶

声明没有优先级的终端符号（令牌种类名称） 或指定的关联性（请参阅令牌种类名称）。

指令：%right ¶

声明右关联的终端符号（令牌种类名称） （请参阅运算符优先级）。

指令：%left ¶

声明左关联的终端符号（令牌类型名称） （请参阅运算符优先级）。

指令：%nonassoc ¶

声明非关联的终端符号（令牌种类名称） （请参阅运算符优先级）。 以关联的方式使用它是语法错误。

指令：%nterm ¶

声明非终端符号的语义值类型（请参阅非终端符号）。

指令：%type ¶

声明符号的语义值类型（请参阅非终端符号）。

指令：%start ¶

指定语法的开始符号（请参阅开始符号）。

指令：%expect ¶

声明预期的移位/减少冲突数，无论是总体冲突还是 对于给定规则 （请参阅禁止冲突警告）。

指令：%expect-rr ¶

声明减少/减少冲突的预期数量，无论是总体冲突还是 对于给定规则 （请参阅禁止冲突警告）。

要更改 的行为，请使用以下命令 指令：bison

指令：%code {code} ¶

指令：%code qualifier {code} ¶

将逐字插入到输出解析器源中 默认位置或位于 指定的位置。 请参见%code 摘要。codequalifier

指令：%debug ¶

检测分析器中的跟踪。被“”淘汰。 请参阅跟踪分析器。%define parse.trace

指令：%define 变量 ¶

指令：%define 变量值 ¶

指令：%define 变量 {value} ¶

指令：%define 变量 “value” ¶

定义一个变量来调整 Bison 的行为。请参阅 %define 摘要。

指令：%defines ¶

指令：%defines defines-file ¶

的历史名称。请参见 %header。%header

指令：%析构函数 ¶

指定分析器应如何回收与 丢弃的符号。请参阅释放丢弃的符号。

指令：%file-prefix “prefix” ¶

指定要用于所有 Bison 输出文件名的前缀。名称 被选择，就好像语法文件被命名为 一样。prefix.y

指令：%header ¶

编写包含令牌种类名称定义的分析器头文件 在语法以及其他一些声明中定义。如果解析器 实现文件被命名，然后被命名为解析器头文件 被命名为 。name.cname.h

对于 C 解析器，解析器头文件声明 除非已定义为宏，或者您使用了标记而没有使用 。因此，如果你是 将（请参阅多个值类型）与需要 其他定义，或者如果您已定义宏或类型 定义（参见语义值的数据类型），您需要安排这些定义 传播到所有模块，例如，将它们放在先决条件中 解析器和任何其他模块都包含的标头 需要。YYSTYPEYYSTYPE<type>%union%unionYYSTYPEYYSTYPE

除非解析器是纯解析器，否则解析器头文件将声明为外部变量。请参阅纯（重入）解析器。yylval

如果还使用了位置，则解析器头文件声明并使用类似于宏 和 的协议。请参阅追踪位置。YYLTYPEyyllocYYSTYPEyylval

如果您希望将 的定义，因为通常需要能够引用 上述声明和令牌种类代码。请参阅标记的语义值。yylexyylex

如果已声明 或 ，则输出 header 还包含他们的代码。 请参见%code 摘要。%code requires%code provides

生成的标题受到 C 的保护，防止多次包含 预处理器保护： ''，其中 和 是前缀（请参阅同一程序中的多个解析器）和 生成的文件名变为大写，每个系列都是非字母数字 字符转换为单个下划线。YY_PREFIX_FILE_INCLUDEDPREFIXFILE

例如，使用 '' 和 ''，标头将按如下方式保护。%define api.prefix {calc}%header "lib/parse.h"

#ifndef YY_CALC_LIB_PARSE_H_INCLUDED
# define YY_CALC_LIB_PARSE_H_INCLUDED
...
#endif /* ! YY_CALC_LIB_PARSE_H_INCLUDED */

在 Bison 3.8 中引入。

指令：%header header-file ¶

与上面相同，但保存在文件中。header-file

指令： %language “language” ¶

指定生成的分析器的编程语言。现在 支持的语言包括 C、C++、D 和 Java。 是 不区分大小写。language

指令：%locations ¶

生成处理位置的代码（请参阅在操作中使用的特殊功能）。这 一旦语法使用特殊的“”，就会启用模式 标记，但如果你的语法不使用它，使用 '' 允许 以获得更准确的语法错误消息。@n%locations

指令：%name-prefix “prefix” ¶

被“”淘汰。请参阅同一程序中的多个解析器。有关 C++ 解析器，请参阅 '' 文档。%define api.prefix {prefix}%define api.namespace

重命名分析器中使用的外部符号，使其以“而不是”开头。在 C 中重命名的符号的精确列表 解析器是 、 、 、 、 、 和 （如果使用位置）。如果使用推送解析器，则 、 、 和 也将重命名。例如，如果使用 ''，则名称变为 、 和 依此类推。prefixyyyyparseyylexyyerroryynerrsyylvalyycharyydebugyyllocyypush_parseyypull_parseyypstateyypstate_newyypstate_delete%name-prefix "c_"c_parsec_lex

与定义相反，有些符号不会被重命名 例如，通过 、 、 、 。api.prefix%name-prefixYYDEBUGYYTOKENTYPEyytoken_kind_tYYSTYPEYYLTYPE

指令：%no-lines ¶

不要在分析器中生成任何预处理器命令 实现文件。通常，Bison 在解析器中编写这些命令 实现文件，以便 C 编译器和调试器将关联 源文件（语法文件）的错误和目标代码。这 指令使它们将错误与解析器实现相关联 文件，将其视为独立的源文件。#line

指令：%output “file” ¶

在 中生成解析器实现。file

指令：%pure-parser ¶

“”的弃用版本（参见 %define Summary），Bison 对此更谨慎地警告 不合理使用。%define api.pure

指令：%require “version” ¶

需要 Bison 的 Vison版本或更高版本。请参阅需要 Bison 版本。version

指令：%skeleton “file” ¶

指定要使用的骨架。

如果不包含 ，则为骨架的名称 文件。 如果是这样，则是一个绝对文件名或相对于 语法文件的目录。 这类似于大多数 shell 解析命令的方式。file/filefile

指令：%token-table ¶

此功能已过时，请在新项目中避免使用。

在分析器实现文件中生成令牌名称数组。这 数组的名称是 ; 是 其内部 Bison 令牌代码为 的令牌。前三个 元素对应于预定义的标记 、 和 ;在这些之后是 语法文件中定义的符号。yytnameyytname[i]iyytname"$end""error""$undefined"

表中的名称包括表示 野牛中的令牌。对于单字符文本和文本字符串，这 包括周围的引号字符和任何转义序列。为 例如，Bison 单字符文字对应于 三个字符的名称，在 C 中表示为 ;和野牛 两个字符的文字字符串对应于五个字符 name，在 C 中表示为 .'+'"'+'""\\/""\"\\\\/\""

指定 时，Bison 还会生成宏定义 对于宏 、 和 ，和 ：%token-tableYYNTOKENSYYNNTSYYNRULESYYNSTATES

YYNTOKENS

终端符号的数量，即最高令牌代码加一。

YYNNTS

非终端符号的数量。

YYNRULES

语法规则的数量，

YYNSTATES

解析器状态的数量（请参阅解析器状态）。

下面是用于查找多字符令牌的代码， 假设令牌的字符存储在 中 并假设令牌不包含任何字符，例如“” 这需要逃避。yytnametoken_buffer"

for (int i = 0; i < YYNTOKENS; i++)
  if (yytname[i]
      && yytname[i][0] == '"'
      && ! strncmp (yytname[i] + 1, token_buffer,
                    strlen (token_buffer))
      && yytname[i][strlen (token_buffer) + 1] == '"'
      && yytname[i][strlen (token_buffer) + 2] == 0)
    break;

不鼓励使用此方法：字符串别名的主要目的是伪造 良好的错误消息，没有描述关键字的拼写。另外 在运行时查找令牌类型会产生（小但明显的）成本。

最后，与变量的 和 值不兼容。%token-tablecustomdetailedparse.error%define

指令：%verbose ¶

编写一个额外的输出文件，其中包含分析器的详细描述 状态以及在该状态下对每种类型的 Lookahead 令牌执行的操作。 有关详细信息，请参阅了解分析器。

指令：%yacc ¶

假装给出了选项 （参见 --yacc），即模仿 Yacc，包括其 命名约定。只有骨架才有意义。有关详细信息，请参阅调整解析器。--yaccyacc.c

当然，作为 Bison 的扩展，有点 自相矛盾......%yacc

3.7.14 %define 摘要

野牛行为的许多特征可以通过以下方式控制 为要素分配单个值。由于历史原因，一些这样的 功能由专用指令赋值，例如 分配开始符号。但是，更新的此类功能是相关的 变量，由指令赋值：%start%define

指令：%define 变量 ¶

指令：%define 变量值 ¶

指令：%define 变量 {value} ¶

指令：%define 变量 “value” ¶

定义为 。variablevalue

值的类型取决于语法。大括号表示 目标语言（例如，命名空间、类型等）。关键字值（否 分隔符）表示有限选择（例如，特征的变体）。字符串 值表示剩余的情况（例如，文件名）。

如果 a 由多个定义，则为错误 次，但请参见 -D name[=value]。variable%define

本节的其余部分总结了接受的变量和值。%define

有些采用布尔值。在这种情况下，野牛会抱怨 如果变量定义不满足以下四个条件之一 条件：variable

1. value是true
2. value被省略（或被指定）。 这相当于 。""true
3. value是。false
4. variable从未定义过。 在本例中，Bison 选择默认值。

什么是被接受的，以及它们的含义和默认值 值，取决于所选的目标语言和/或分析器骨架 （见野牛宣言摘要，见野牛宣言摘要）。 未接受的 s 会产生错误。下面介绍了一些被接受的 s。variablevariablevariable

指令：%define api.filename.type {type} ¶

• 语言： C++
• 目的： 在 Bison 的默认位置和位置中定义文件名的类型 类型。请参阅公开位置类。
• 接受的价值观： 任何可打印（通过流）和可比较（带有 和 ）的类型。==!=
• 默认值：.const std::string
• 历史： 在 Bison 2.0 中引入（与 default），在 Bison 3.7 中重命名为 （默认）。filename_typestd::stringapi.filename.typeconst std::string

指令：%define api.header.include {“header.h”} ¶

指令：%define api.header.include {<header.h>} ¶

• 语言： C （yacc.c)
• 用途：指定生成的分析器应如何包含生成的标头。

  从历史上看，当使用 option 或时，会生成一个标头并将其的精确副本粘贴到 生成的解析器实现文件。从 Bison 3.6 开始，它是 d 作为 ''，而不是重复的，除非是 ''，见下文。-d--headerbison#include"basename.h"filey.tab

  该变量允许控制如何生成 解析器生成的标头。例如：api.header.include#include

  %define api.header.include {"parse.h"}
  

  或

  %define api.header.include {<parser/parse.h>}
  

  使用不会更改生成的名称 标头，只是它的包含方式。api.header.include

  要解决 Automake（与 一起运行）的限制，当输出文件为 时，未预定义 。将其定义为 避免重复。ylwrapbison--yaccapi.header.includey.tab.c

• 接受的价值观： 的参数。#include
• 默认值： ''，除非头文件是 ， 其中 是生成的标头的名称，没有 目录部分。例如，使用 ''，默认为 ''，而不是 ‘’."header-basename"y.tab.hheader-basenamebison -d calc/parse.yapi.header.include"parse.h""calc/parse.h"
• 历史： 在 Bison 3.4 中引入。默认为“”，因为 Bison 3.7，除非头文件是 ."basename.h"y.tab.h

指令：%define api.location.file “file” ¶

指令：%define api.location.file none ¶

• 语言： C++
• 目的： 定义 Bison 的默认位置和位置的文件的名称 生成类型。请参阅公开位置类。
• 接受的价值观：

  none

  如果启用了位置，则在头文件中生成 和 类的定义，否则为 分析器实现。positionlocation%header

  "file"

  生成 和 类的定义 在。此文件名可以是相对的（与解析器文件所在的位置 output） 或绝对值。positionlocationfile

• 默认值： 如果未启用位置，或者用户位置类型为 指定（参见）。否则，Bison's 将在 （请参阅 C++ 位置） 中生成。api.location.typelocationlocation.hh
• 历史： 在 Bison 3.2 中引入。

指令：%define api.location.include {“file”} ¶

指令：%define api.location.include {<file>} ¶

• 语言： C++
• 目的： 指定如何包含定义 and 类的生成文件。当类向应用程序/库的其余部分公开时，这是有道理的 另一个目录。请参阅公开位置类。positionlocationlocation
• 接受的值：. 的参数。#include
• 默认值： '' 其中 是目录部分 输出。例如，如果被给予。"dir/location.hh"dirsrc/parse--output=src/parse/parser.cc
• 历史： 在 Bison 3.2 中引入。

指令：%define api.location.type {type} ¶

• 语言：C、C++、Java
• 用途：定义位置类型。 请参阅位置的数据类型和用户定义的位置类型。
• 接受的值： String
• 默认值：无
• 历史： 在 Bison 2.7 for C++ 和 Java 中引入，在 Bison 3.4 for C 中引入 最初在 Bison 2.5 和 2.6 中命名。location_type

指令：%define api.namespace {namespace} ¶

• 语言： C++
• 用途：指定分析器类的命名空间。 例如，如果指定：

  %define api.namespace {foo::bar}
  

  Bison 在参考文献中逐字使用，例如：foo::bar

  foo::bar::parser::value_type
  

  但是，要打开命名空间，Bison 会删除任何前导，然后 对任何剩余的匹配项进行拆分：::

  namespace foo { namespace bar {
    class position;
    class location;
  } }
  

• 接受的价值观： 任何不带尾随的绝对或相对 C++ 命名空间引用。例如，或 ."::""foo""::foo::bar"
• 默认值：，除非使用了过时的“” 命令。yy%name-prefix "prefix"

指令：%define api.parser.class {name} ¶

• 语言： C++， Java， D
• 目的： 分析器类的名称。
• 接受的价值观： 任何有效标识符。
• 默认值： 在 C++ 中，.在 D 和 Java 中，或者（参见 Java Bison 接口）。parserYYParserapi.prefixParser
• 历史： 在 Bison 3.3 中引入以替换 .parser_class_name

指令：%define api.prefix {prefix} ¶

• 语言：C、C++、Java
• 用途：重命名导出的符号。 请参阅同一程序中的多个解析器。
• 接受的值： String
• 默认值：对于 Java，否则。YYyy
• 历史： 在 Bison 2.6 中引入，其参数用双引号括起来。使用大括号 从 Bison 3.0 开始（向后仍支持双引号 兼容性）。

指令：%define api.pure purity ¶

• 语言： C
• 目的：请求纯（可重入）解析器程序。 请参阅纯（重入）解析器。
• 接受的值： ， ，truefalsefull

  可以省略该值：这等效于按原样指定 布尔值的情况。true

  使用时，解析器将重入。这 更改签名（请参阅纯解析器的调用约定），以及激活位置跟踪时的签名，如下所示 下面。%define api.pure fullyylexyyerror

  该值与该值非常相似，唯一的 不同之处在于 在 Yacc 解析器上没有签名，出于历史原因。truefullyyerror%parse-param

  也就是说，如果传递了 ''，则 的原型是：%locations %define api.pureyyerror

  void yyerror (char const *msg);                 // Yacc parsers.
  void yyerror (YYLTYPE *locp, char const *msg);  // GLR parsers.
  

  但是，如果 '' 是 used，则两个解析器具有相同的签名：%locations %define api.pure %parse-param {int *nastiness}

  void yyerror (YYLTYPE *llocp, int *nastiness, char const *msg);
  

  （请参阅错误报告功能 yyerror)

• 默认值：false
• 历史： 该值是在 Bison 2.7 中引入的full

指令：%define api.push-pull kind ¶

• 语言：C（仅限确定性解析器）、D、Java
• 用途：请求拉取解析器和/或推送解析器。 请参阅推送解析器。
• 接受的值： ， ，pullpushboth
• 默认值：pull

指令：%define api.symbol.prefix {prefix} ¶

• 语言：全部
• 目的： 为符号种类的名称添加前缀。例如

  %define api.symbol.prefix {S_}
  %token FILE for ERROR
  %%
  start: FILE for ERROR;
  

  在 C 语言中生成以下定义：

  /* Symbol kind.  */
  enum yysymbol_kind_t
  {
    S_YYEMPTY = -2,   /* No symbol.  */
    S_YYEOF = 0,      /* $end  */
    S_YYERROR = 1,    /* error  */
    S_YYUNDEF = 2,    /* $undefined  */
    S_FILE = 3,       /* FILE  */
    S_for = 4,        /* for  */
    S_ERROR = 5,      /* ERROR  */
    S_YYACCEPT = 6,   /* $accept  */
    S_start = 7       /* start  */
  };
  

• 接受的价值观： 任何非空字符串。必须是目标语言的有效标识符 （通常是字母、下划线和 -的非空序列，而不是在 begin— 数字）。

  空前缀（通常）无效：

  • 在 C 中，它会与宏发生冲突，并且 潜在的令牌类型定义和符号类型定义将 碰撞;YYERROR
  • 未命名的符号（例如“”）的名称以数字开头;'+'
  • 即使在具有作用域枚举的语言（如 Java）中，空前缀也是 危险：符号名称可能与目标语言关键字发生冲突，或者 与班级的其他成员一起。SymbolKind
• 默认值：在 C 中，在 C++ 和 Java 中，在 D 中为空。YYSYMBOL_S_
• 历史： 在 Bison 3.6 中引入。

指令：%define api.token.constructor ¶

• 语言： C++，D
• 目的： 请求将符号作为一个整体（类型、值和可能 位置）在扫描仪中。在 C++ 的情况下，它仅在以下情况下才有效 启用基于变体的语义值（请参阅 C++ 变体），有关详细信息，请参阅完整符号。在 D 中，令牌构造函数同时使用这两种方法 '' 和 ''.%union%define api.value.type union
• 接受的价值观： 布尔。
• 默认值：false
• 历史： 在 Bison 3.0 中引入。

指令：%define api.token.prefix {prefix} ¶

• 语言：全部
• 目的： 在生成令牌名称时，在 目标语言。例如

  %define api.token.prefix {TOK_}
  %token FILE for ERROR
  %%
  start: FILE for ERROR;
  

  在生成的源文件中生成符号 、 和 的定义。特别是扫描仪 必须使用这些带前缀的标记名称，而语法本身可能仍使用 短名称（如上面给出的示例规则所示）。生成的 信息文件 （， ， ） 不是 由此前缀修改。TOK_FILETOK_forTOK_ERROR*.output*.xml*.gv

  Bison 还为语义值并集的生成成员名称添加前缀。 有关详细信息，请参阅生成语义值类型 详。

  有关完整示例，请参阅 Calc++ Parser 和 Calc++ Scanner。

• 接受的价值观： 任何字符串。必须是目标语言中的有效标识符前缀 （通常，可能是空的字母、下划线和 —not at 开头 - 数字）。
• 默认值： 空
• 历史： 在 Bison 3.0 中引入。

指令：%define api.token.raw ¶

• 语言： 都
• 目的： 输出文件通常定义具有 Yacc 兼容令牌代码的令牌类型的枚举：从 257 开始的序列号，除了 对于代表自己的单字符标记（例如，在 ASCII 中， '' 编号为 65）。但是，解析器使用符号类型，这些符号类型从 0 开始按顺序分配数字。因此，每次 扫描程序返回一个（外部）令牌类型，它必须映射到 （内部）符号种类。'a'

  设置后，令牌种类的代码被强制为 与符号种类相吻合。这样可以节省每个要映射的令牌的表查找 它们从令牌种类到符号种类，也节省了一代 的映射表。增益通常适中，但在极端情况下 （非常简单的用户操作），可以观察到 10% 的改进。api.token.raw

  设置后，语法不能使用字符文字 （例如“”）。api.token.raw'a'

• 接受的值： Boolean.
• 默认值：在 D 中，否则truefalse
• 历史： 在 Bison 3.5 中引入。最初在 Bison 1.25 中引入 ''，但从未工作过，并在 Bison 1.29 中被删除。%raw

指令：%define api.value.automove ¶

• 语言： C++
• 目的： 设规则右侧的语义值的出现次数为 隐式上交的右值。启用后，语法如下：

  exp:
    "number"     { $$ = make_number ($1); }
  | exp "+" exp  { $$ = make_binary (add, $1, $3); }
  | "(" exp ")"  { $$ = $2; }
  

  实际上编译得好像你写过：

  exp:
    "number"     { $$ = make_number (std::move ($1)); }
  | exp "+" exp  { $$ = make_binary (add,
                                     std::move ($1),
                                     std::move ($3)); }
  | "(" exp ")"  { $$ = std::move ($2); }
  

  在启用自动移动的情况下多次使用某个值通常是错误的。 例如，而不是：

  exp: "twice" exp  { $$ = make_binary (add, $2, $2); }
  

  写：

  exp: "twice" exp { auto v = $2; $$ = make_binary (add, v, v); }
  

  在其中一个上使用是很诱人的，但是 C++ 中的参数计算顺序未指定。std::movev

• 接受的价值观： 布尔。
• 默认值：false
• 历史： 在 Bison 3.2 中引入

指令：%define api.value.type 支持 ¶

指令：%define api.value.type {type} ¶

• 语言： 都
• 目的： 语义值的类型。
• 接受的价值观：

  '{}'

  这种语法根本没有语义价值。这没有得到适当的支持 还。

  “联合指令”（C、C++、D）

  由于该指令，该类型是定义的。你没有 在这种情况下定义，使用就足够了。 见《国际电联宣言》。 例如：%unionapi.value.type%union

  %define api.value.type union-directive
  %union
  {
    int ival;
    char *sval;
  }
  %token <ival> INT "integer"
  %token <sval> STR "string"
  

  “联合”（C、C++）

  符号使用类型名称定义，Bison 将从中生成 .例如：union

  %define api.value.type union
  %token <int> INT "integer"
  %token <char *> STR "string"
  

  大多数 C++ 对象不能存储在 ，使用 '' 相反。unionvariant

  “变体”（C++）

  这类似于 ，但使用特殊的存储技术来 允许使用任何类型的 C++ 对象。例如：union

  %define api.value.type variant
  %token <int> INT "integer"
  %token <std::string> STR "string"
  

  请参阅 C++ 变体。

  '{类型}'

  将此用作语义值。type

  %code requires
  {
    struct my_value
    {
      enum
      {
        is_int, is_str
      } kind;
      union
      {
        int ival;
        char *sval;
      } u;
    };
  }
  %define api.value.type {struct my_value}
  %token <u.ival> INT "integer"
  %token <u.sval> STR "string"
  

• 默认值：
  • - union-directive如果使用，否则......%union
  • - int如果使用 type 标记（即 '' 或 ''），否则......%token <type>…%nterm <type>…
  • -定义。
• 历史： 在 Bison 3.0 中引入。仅在 2.3b 中为 Java 引入。stype

指令：%define api.value.union.name 名称 ¶

• 语言： C
• 目的： 生成的标记（不是 的名称）。此变量设置为使用“”时。没有明确的理由给这个工会起个名字。uniontypedefid%union id
• 接受的价值观： 任何有效标识符。
• 默认值：.YYSTYPE
• 历史： 在 Bison 3.0.3 中引入。

指令：%define lr.default-reduction 当 ¶

• 语言： 全部
• 用途：指定允许的状态类型 包含默认减少。请参阅默认减少。
• 接受的值： ， ，mostconsistentaccepting
• 默认值：
  • accepting如果是 .lr.typecanonical-lr
  • most否则。
• 历史： 在 2.5 中引入，在 3.0 中重命名为。lr.default-reductionslr.default-reduction

指令：%define lr.keep-unreachable-state ¶

• 语言： 全部
• 目的：请求 Bison 允许无法访问的解析器状态 保留在分析器表中。请参阅无法访问的状态。
• 接受的值： Boolean
• 默认值：false
• 历史： 在 2.3b 中引入，在 2.5 和 3.0 中重命名为 3.0。lr.keep_unreachable_stateslr.keep-unreachable-stateslr.keep-unreachable-state

指令：%define lr.type type ¶

• 语言： 全部
• 用途：指定 LR（1） 系列。请参阅 LR 表构造。
• 接受的值： ， ，lalrielrcanonical-lr
• 默认值：lalr

指令：%define namespace {namespace} ¶

已过时api.namespace

指令：%define parse.assert ¶

• 语言：C、C++
• 用途：发出运行时断言以捕获无效用途。 在 C 语言中，解析器实现中的一些重要不变量是 启用此选项时选中。

  在 C++ 中，使用变体时（请参阅 C++ 变体），符号必须是 正确建造和销毁。此选项检查这些约束 使用运行时类型信息 （RTTI）。因此，生成的代码不能 在禁用 RTTI 的情况下进行编译（通过编译器选项，例如 ）。-fno-rtti

• 接受的值： Boolean
• 默认值：false

指令：%define parse.error 详细程度 ¶

• 语言： 都
• 目的： 控制语法错误消息的生成。请参阅错误报告。
• 接受的价值观：
  • simple传递给的错误消息只是 .yyerror"syntax error"
  • detailed错误消息报告意外令牌，也可能是预期的令牌。 但是，当未启用 LAC 时，此报告通常不正确 （见 LAC）。支持令牌名称国际化。
  • verbose与 相似（但不如）。D 分析器不支持此值。detailed

    错误消息报告意外令牌，也可能是预期的令牌。 但是，当未启用 LAC 时，此报告通常不正确 （见 LAC）。

    不支持令牌国际化。在 令牌别名不可移植。

  • custom用户负责通过定义函数来生成语法错误消息。请参阅语法错误报告功能yyreport_syntax_error。yyreport_syntax_error
• 默认值：simple
• 历史： 在 3.0 中引入，支持 和 。值，并在 3.6 中引入。simpleverbosecustomdetailed

指令： %define parse.lac 当 ¶

• 语言：C/C++（仅限确定性解析器）、D 和 Java。
• 目的：启用 LAC（前瞻校正）以改进 语法错误处理。请参见 LAC。
• 接受的值： ，nonefull
• 默认值：none

指令：%define parse.trace ¶

• 语言：C、C++、D、Java
• 用途：需要分析器检测进行跟踪。 请参阅跟踪分析器。

  在 C/C++ 中，定义宏（或使用 ''），请参阅同一程序中的多个解析器）改为 1（如果尚未定义），以便调试工具是 编译。YYDEBUGprefixDEBUG%define api.prefix {prefix}

• 接受的值： Boolean
• 默认值：false

指令：%define parser_class_name {name} ¶

已过时api.parser.class

3.7.15 %代码摘要

该指令将代码逐字插入到输出中 解析器源位于预定义位置集中的任何一个位置。因此，它服务于 作为传统 Yacc 的灵活且用户友好的替代品 序幕。本节总结了 各种目标语言的功能 由野牛支持。详细讨论如何使用代替 C/C++ 以及为什么使用 这样做是有利的，请参阅序幕替代方案。%code%{code%}%code%code%{code%}

指令：%code {code} ¶

这是指令的无条件形式。它 在与语言相关的默认位置逐字插入 在解析器实现中。%codecode

对于 C/C++，默认位置是分析器实现文件 在分析器头文件的常规内容之后。因此， 在大多数情况下，不合格的表格会被替换。%{code%}

对于 D 和 Java，默认位置位于解析器类内。

指令：%code qualifier {code} ¶

这是指令的限定形式。 确定 的目的，因此 Bison 应插入它的位置。也就是说，如果需要 指定不属于 非合格表单选择的默认位置，使用 这种形式。%codequalifiercodecode%code

对于任何特定的限定词或不合格的形式，如果有 指令的多次出现，Bison 连接 按其在语法中出现的顺序排列的指定代码 文件。%code

并非所有目标语言都接受所有限定词。未接受 限定符产生错误。一些公认的限定词是：

requires ¶

• 语言： C， C++
• 目的： 这是编写值所需的依赖项代码的最佳位置，并且 位置类型（和 C 格式）。换言之， 这是定义指令中引用的类型的最佳位置。 在 C 语言中，如果你用来覆盖 Bison 的默认值和定义，那么它也是最好的地方。但是你 应该宁愿和 .YYSTYPEYYLTYPE%union#defineYYSTYPEYYLTYPE%defineapi.value.typeapi.location.type
• 地点： 解析器头文件和解析器实现文件之前的 Bison 生成的值和位置类型的定义（和 C 语言）。YYSTYPEYYLTYPE

provides ¶

• 语言： C， C++
• 目的：这是编写其他定义和 应提供给其他模块的声明。
• 地点： 解析器头文件和解析器实现文件在 Bison 生成的值和位置类型（和 C 语言）以及令牌定义。YYSTYPEYYLTYPE

top ¶

• 语言： C， C++
• 目的：不合格的或通常应该比 .然而 有时需要插入更靠近顶部的代码 解析器实现文件。例如：%code%code requires%code top

  %code top {
    #define _GNU_SOURCE
    #include <stdio.h>
  }
  

• 位置：靠近分析器实现文件的顶部。

imports ¶

• 语言： D， Java
• 目的：这是编写 Java import 指令的最佳位置。D 语法 允许在整个代码中使用 import 语句。
• 位置：任何 Java 包指令和 在任何类定义之前。任何类定义之前的分析器 D 文件。

虽然我们说插入位置与语言有关，但它们确实如此 从技术上讲，依赖于骨架。非标准骨架的编写者 但是，应根据行为选择其位置 标准野牛骨架。

4.3.1 调用约定yylex

返回的值必须是 它刚刚找到的那种代币;零值或负值表示 输入结束。yylex

当标记类型在语法规则中由名称引用时，该名称 在解析器实现中，文件成为枚举的枚举器，其定义是枚举的正确数字代码 令牌种类。因此，应使用名称来指示该类型。 请参阅符号、终端和非终端。yytoken_kind_tyylex

当字符文字在语法规则中引用标记时， 该字符的数字代码也是令牌类型的代码。所以可以简单地返回该字符代码，可能转换为以避免符号扩展。空字符不得 以这种方式使用，因为它的代码为零，这意味着输入结束。yylexunsigned char

下面是一个示例，显示了这些内容：

int
yylex (void)
{
  …
  if (c == EOF)    /* Detect end-of-input. */
    return YYEOF;
  …
  else if (c == '+' || c == '-')
    return c;      /* Assume token kind for '+' is '+'. */
  …
  else
    return INT;    /* Return the kind of the token. */
  …
}

此接口经过精心设计，可以在不更改 定义的情况下使用实用程序的输出。lexyylex

4.3.2 特殊代币

除了用户定义的令牌外，Bison 还会生成一些特殊令牌 可能会回来。yylex

令牌表示文件的结尾，并向解析器发出信号 之后什么都没有了。请参阅 yylex 的调用约定，了解 例。YYEOF

返回告诉解析器发现了一些词法错误。 它会发出一条关于“无效令牌”的错误消息，然后输入 error-recovery（请参阅错误恢复）。返回未知令牌种类 导致完全相同的行为。YYUNDEF

返回要求分析器在不发出错误消息的情况下输入错误恢复。这样，词法分析器可以 生成有关无效输入的准确错误消息（某些 解析器不能做），但受益于 解析 器。YYerror

int
yylex (void)
{
  …
  switch (c)
    {
      …
      case '0': case '1': case '2': case '3': case '4':
      case '5': case '6': case '7': case '8': case '9':
        …
        return TOK_NUM;
      …
      case EOF:
        return YYEOF;
      default:
        yyerror ("syntax error: invalid character: %c", c);
        return YYerror;
    }
}

4.3.3 通过字符串文字查找标记

如果语法使用文字字符串标记，则有两种方法可以确定它们的标记类型代码：yylex

• 如果语法将符号标记名称定义为文本的别名 字符串标记，可以像所有其他名称一样使用这些符号名称。 在这种情况下，语法文件中使用文本字符串标记具有 对 .yylexyylex

  这是首选方法。

• yylex可以在表中搜索多字符令牌。不建议使用此方法：字符串别名的主要用途是 伪造良好的错误消息，而不是描述关键字的拼写。在 此外，在运行时查找令牌类型会产生 （小但 显着）成本。yytname

  仅当使用声明时，才会生成该表。参见野牛宣言摘要。yytname%token-table

4.3.4 代币的语义值

在普通（非重入）解析器中，令牌的语义值必须 存储到全局变量中。当您仅使用 语义值的一种数据类型具有该类型。因此，如果 类型为（默认值），您可以将其写成：yylvalyylvalintyylex

  …
  yylval = value;  /* Put value onto Bison stack. */
  return INT;      /* Return the kind of the token. */
  …

当您使用多种数据类型时，的类型是联合制作的 从宣言（见《联盟宣言》）。所以当你存储 令牌的值，您必须使用适当的联合成员。如果声明如下所示：yylval%union%union

%union {
  int intval;
  double val;
  symrec *tptr;
}

那么代码可能如下所示：yylex

  …
  yylval.intval = value; /* Put value onto Bison stack. */
  return INT;            /* Return the kind of the token. */
  …

4.3.5 代币的文本位置

如果您使用的是“”功能（请参阅跟踪位置） 在跟踪标记和分组的文本位置的操作中， 那么，您必须在 中提供此信息。该函数期望找到刚刚解析的标记的文本位置 在全局变量 中。所以必须存储适当的 该变量中的数据。@nyylexyyparseyyllocyylex

默认情况下，的值是一个结构，您只需要 初始化操作将使用的成员。这 四个成员分别称为 、 和 。请注意，使用 功能使解析器明显变慢。yyllocfirst_linefirst_columnlast_linelast_column

的数据类型名称为 。yyllocYYLTYPE

4.3.6 纯解析器的调用约定

当您使用 Bison 声明请求 纯的、可重入的解析器，全局通信变量，不能使用。（请参阅纯（重入）解析器。在这样的解析器中，两者 全局变量被作为参数传递给 的指针替换。您必须声明它们，如下所示，并传递信息 通过这些指针存储它来返回。%define api.pure fullyylvalyyllocyylex

int
yylex (YYSTYPE *lvalp, YYLTYPE *llocp)
{
  …
  *lvalp = value;  /* Put value onto Bison stack. */
  return INT;      /* Return the kind of the token. */
  …
}

如果语法文件不使用“”结构来引用 文本位置，则不会定义类型。在 在这种情况下，省略第二个参数; 将被调用 只有一个参数。@YYLTYPEyylex

如果您希望将其他参数传递给 ，请使用 just like （请参阅解析器函数 yyparse）。要将其他参数传递给 和 ，请使用 。yylex%lex-param%parse-paramyylexyyparse%param

指令： %lex-param {argument-declaration} ... ¶

指定 that are additional argument 声明。您可以通过一个或多个此类声明，即 等同于重复。argument-declarationyylex%lex-param

指令： %param {argument-declaration} ... ¶

指定附加 / 参数声明。这相当于 ‘’.您可以通过一项或多项 声明，这相当于重复.argument-declarationyylexyyparse%lex-param {argument-declaration} … %parse-param {argument-declaration} …%param

例如：

%lex-param   {scanner_mode *mode}
%parse-param {parser_mode *mode}
%param       {environment_type *env}

生成以下签名：

int yylex   (scanner_mode *mode, environment_type *env);
int yyparse (parser_mode *mode, environment_type *env);

如果添加了 ''：%define api.pure full

int yylex   (YYSTYPE *lvalp, scanner_mode *mode, environment_type *env);
int yyparse (parser_mode *mode, environment_type *env);

最后，如果 '' 和 是 使用：%define api.pure full%locations

int yylex   (YYSTYPE *lvalp, YYLTYPE *llocp,
             scanner_mode *mode, environment_type *env);
int yyparse (parser_mode *mode, environment_type *env);

4.4.1 错误报告功能yyerror

Bison 解析器检测到语法错误（或解析错误） 每当它读取不能满足任何语法规则的标记时。一 语法中的 action 也可以显式声明错误，使用 宏（请参阅在操作中使用的特殊功能）。YYERROR

Bison 解析器希望通过调用错误来报告错误 必须提供名为 的报告函数。是的 每当发现语法错误时调用，并且它 接收一个参数。对于语法错误，字符串通常为 .yyerroryyparse"syntax error"

如果在 Bison 声明部分（参见 Bison 声明部分），然后 Bison 提供 一个更详细和具体的错误消息字符串，而不仅仅是普通的 .但是，该消息有时包含 如果未启用 LAC，则信息不正确（请参阅 LAC）。%define parse.error detailedcustom"syntax error"

解析器可以检测到另一种错误：内存耗尽。这 当输入包含非常深的结构时，可能会发生这种情况 嵌 套。你不太可能遇到这种情况，因为野牛 解析器通常会自动将其堆栈扩展到一个非常大的限制。但 如果内存耗尽，则通常调用 fashion，但参数字符串是 。yyparseyyerror"memory exhausted"

在某些情况下，诊断是 之前自动从英语翻译成其他语言 它们被传递给 .请参阅 Parser 国际化。"syntax error"yyerror

以下定义在简单程序中就足够了：

void
yyerror (char const *s)
{

  fprintf (stderr, "%s\n", s);
}

返回后，后者将尝试 错误恢复（如果您编写了合适的错误恢复语法规则） （请参阅错误恢复）。如果无法恢复，将 立即返回 1。yyerroryyparseyyparse

显然，在位置跟踪纯解析器中，应该有 对当前位置的访问。有了 ，这是 GLR 解析器确实如此，但 Yacc 解析器并非如此，因为 历史原因，这就是原因 首选。yyerror%define api.pure%define api.pure full%define api.pure

使用时，具有 以下签名：%locations %define api.pure fullyyerror

void yyerror (YYLTYPE *locp, char const *msg);

原型只是 Bison 生成代码的指示 使用。Bison 生成的代码总是忽略返回的 值，因此可以返回任何类型，包括 . 此外，可以是可变函数;这就是为什么 消息始终最后传递。yyerroryyerrorvoidyyerror

传统上返回一个 总是 被忽略了，但这纯粹是出于历史原因，而且是 最好，因为它更准确地描述了 的返回类型。yyerrorintvoidyyerror

该变量包含语法错误的数量 到目前为止报道。通常，此变量是全局变量;但如果你 请求纯解析器（请参阅纯（重入）解析器） 那么它是一个局部变量，只有操作才能访问。yynerrs

4.4.2 语法错误报告功能yyreport_syntax_error

如果调用 ''（请参阅 Bison 声明部分），则解析器不再将语法错误消息传递给 ，而是通过调用函数将该任务委托给用户。%define parse.error customyyerroryyreport_syntax_error

以下函数和类型是 “”： 它们在 实现文件 （） 并且只能从那里获得。他们 旨在从语法的结语中使用。static*.c

功能：static int yyreport_syntax_error （const yypcontext_t *ctx） ¶

向用户报告语法错误。成功时返回 0，开 记忆力耗尽。是否使用取决于用户。YYENOMEMyyerror

使用以下类型和函数生成错误消息。

类型：yypcontext_t ¶

捕获语法错误情况的不透明类型。

类型：yysymbol_kind_t ¶

所有语法符号、标记和非终端的枚举。其 枚举器是从符号名称伪造的：

enum yysymbol_kind_t
{
  YYSYMBOL_YYEMPTY = -2,      /* No symbol.  */
  YYSYMBOL_YYEOF = 0,         /* "end of file"  */
  YYSYMBOL_YYerror = 1,       /* error  */
  YYSYMBOL_YYUNDEF = 2,       /* "invalid token"  */
  YYSYMBOL_PLUS = 3,          /* "+"  */
  YYSYMBOL_MINUS = 4,         /* "-"  */
  [...]
  YYSYMBOL_VAR = 14,          /* "variable"  */
  YYSYMBOL_NEG = 15,          /* NEG  */
  YYSYMBOL_YYACCEPT = 16,     /* $accept  */
  YYSYMBOL_exp = 17,          /* exp  */
  YYSYMBOL_input = 18         /* input  */
};
typedef enum yysymbol_kind_t yysymbol_kind_t;

功能：静态yysymbol_kind_t yypcontext_token（const yypcontext_t *ctx） ¶

“意外”令牌：导致 语法错误。如果没有前瞻，则返回。YYSYMBOL_YYEMPTY

功能：静态 YYLTYPE * yypcontext_location （const yypcontext_t *ctx） ¶

语法错误的位置（意外标记的位置）。

功能： static int yypcontext_expected_tokens （const yypcontext_t *ctx， yysymbol_kind_t argv[]， int argc） ¶

填充预期的标记，其中从不包含 、 或 。argvYYSYMBOL_YYEMPTYYYSYMBOL_YYerrorYYSYMBOL_YYUNDEF

永远不要把更多的元素放进去，在成功上 返回存储在 中的令牌数。如果还有更多 预期的令牌比 ，填满并返回 0. 如果没有预期的令牌，则也返回 0，但设置为 。argcargvargvargcargvargcargv[0]YYSYMBOL_YYEMPTY

启用 LAC 后，可能会在错误时返回负数， 例如内存耗尽。YYENOMEM

如果为 null，则返回存储所有可能文件所需的大小 值，它总是小于 。argvYYNTOKENS

功能：静态常量 char * yysymbol_name（symbol_kind_t符号）¶

其种类为 的符号的名称，可能已翻译。symbol

自定义语法错误函数如下所示。此实现是 不适合国际化，请参阅示例以获取更好的替代方案。c/bistromathic

static int
yyreport_syntax_error (const yypcontext_t *ctx)
{
  int res = 0;
  YYLOCATION_PRINT (stderr, *yypcontext_location (ctx));
  fprintf (stderr, ": syntax error");
  // Report the tokens expected at this point.
  {
    enum { TOKENMAX = 5 };
    yysymbol_kind_t expected[TOKENMAX];
    int n = yypcontext_expected_tokens (ctx, expected, TOKENMAX);
    if (n < 0)
      // Forward errors to yyparse.
      res = n;
    else
      for (int i = 0; i < n; ++i)
        fprintf (stderr, "%s %s",
                 i == 0 ? ": expected" : " or", yysymbol_name (expected[i]));
  }
  // Report the unexpected token.
  {
    yysymbol_kind_t lookahead = yypcontext_token (ctx);
    if (lookahead != YYSYMBOL_YYEMPTY)
      fprintf (stderr, " before %s", yysymbol_name (lookahead));
  }
  fprintf (stderr, "\n");
  return res;
}

您仍然必须提供一个函数，例如用于 报告内存耗尽。yyerror

4.6.1 实现国际化

使用 Bison 生成的解析器的包的维护者启用 通过以下方式实现解析器输出的国际化 步骤。在这里，我们假设一个使用 GNU Autoconf 和 GNU 自动生成。

1. 进入包含所用 GNU Autoconf 宏的目录 通过包（通常称为）复制 Bison 安装的文件 '' 在 Bison 的安装目录中。 例如：m4bison-i18n.m4share/aclocal/bison-i18n.m4

   cp /usr/local/share/aclocal/bison-i18n.m4 m4/bison-i18n.m4
   

2. 在顶级 中，在调用之后添加 的调用。这个宏是 在之前复制的文件中定义。它 导致找到变量的值，并定义源语言 符号在 Bison 生成的解析器。configure.acAM_GNU_GETTEXTBISON_I18Nbison-i18n.m4configureBISON_LOCALEDIRYYENABLE_NLS
3. 在程序的功能中，指定目录 包含 Bison 的运行时消息目录，通过调用 '' 的域名为 ''。 例如：mainbindtextdomainbison-runtime

   bindtextdomain ("bison-runtime", BISON_LOCALEDIR);
   

   通常，这会显示在包已有的任何其他调用之后。在这里，我们依靠 '' 定义为通过 .bindtextdomain (PACKAGE, LOCALEDIR)BISON_LOCALEDIRMakefile

4. 在控制函数编译的 中，使 '' 可用作 C 预处理器宏， 在“”或“”中。例如：Makefile.ammainBISON_LOCALEDIRDEFSAM_CPPFLAGS

   DEFS = @DEFS@ -DBISON_LOCALEDIR='"$(BISON_LOCALEDIR)"'
   

   或：

   AM_CPPFLAGS = -DBISON_LOCALEDIR='"$(BISON_LOCALEDIR)"'
   

5. 最后，调用命令生成生成 基础设施。autoreconf

4.6.2 代币国际化

当变量设置为 或 时，可以对令牌别名进行国际化：%defineparse.errorcustomdetailed

%token
    '\n'   _("end of line")
  <double>
    NUM    _("number")
  <symrec*>
    FUN    _("function")
    VAR    _("variable")

语法的其余部分可以自由使用标记符号 （） 或其别名 （），但不使用 国际化标记 （）。FUN"function"_("function")

如果至少有一个令牌别名是国际化的，则生成的解析器 将同时使用 和 ，必须定义 （参见 GNU gettext 实用程序中的程序员视图）。它们仅用于标记为要翻译的字符串别名。 换言之，即使您的目录具有 “function”，则使用N__

%token
  <symrec*>
    FUN      "function"
    VAR    _("variable")

“function”将在调试跟踪和错误消息中显示为未翻译。

除非由用户定义，否则将提供文件末标记 ， “end of file”作为别名。如果用户 国际化代币。若要将其映射到另一个字符串，请使用：YYEOF

%token END 0 _("end of input")

5.3.1 何时需要优先

考虑以下模棱两可的语法片段（模棱两可，因为 输入 '' 可以通过两种不同的方式进行解析）：1 - 2 * 3

expr:
  expr '-' expr
| expr '*' expr
| expr '<' expr
| '(' expr ')'
…
;

假设解析器已经看到了标记 ''、'' 和 ''; 它应该通过减法运算符的规则来减少它们吗？它 取决于下一个令牌。当然，如果下一个标记是“”，我们 必须减少;移位是无效的，因为没有一个规则可以减少 令牌序列 '' 或任何以该序列开头的内容。但是，如果 下一个标记是 '' 或 ''，我们有一个选择：要么 移位或减少将允许解析完成，但 不同的结果。1-2)- 2 )*<

要决定野牛应该做哪一个，我们必须考虑结果。如果 下一个运算符令牌被移动，然后必须减少它 首先，为了允许另一个机会来减少差异。 结果是（实际上）''。另一方面 手，如果减法在移位前减少，结果 是 ''。显然，选择换档或 reduce 应取决于运算符的相对优先级 '' 和 ： '' 应该首先移动，但不要 ‘’.op1 - (2 op 3)op(1 - 2) op 3-op*<

诸如“”之类的输入呢？这应该是 '' 还是应该是 ''？对于大多数人 运算符我们更喜欢前者，这称为左关联。 后一种选择，即正确的关联，是可取的 赋值运算符。左关联或右关联的选择是一个 解析器在堆栈时选择移位还是减少的问题 包含 ''，并且 Lookahead 标记为 ''： Moving 使右联想。1 - 2 - 5(1 - 2) - 51 - (2 - 5)1 - 2-

5.3.2 指定运算符优先级

Bison 允许您使用运算符优先级指定这些选项 声明和 .每个这样的声明 包含令牌列表，这些令牌是优先级和 正在宣布关联性。宣言使所有 那些运算符左关联，声明使 他们右联想。第三种选择是 ，它 声明在“在 行“。 最后一种选择，只允许定义 优先级，根本没有关联性。因此，任何 仍然存在的与关联相关的冲突将报告为 编译时错误。该指令创建运行时 错误：以关联方式使用运算符是语法错误。这 指令会创建编译时错误：运算符可能涉及与关联性相关的冲突，这与 语法作者的期望。%left%right%left%right%nonassoc%precedence%nonassoc%precedence

不同运算符的相对优先级由 声明它们的顺序。第一个优先级/关联性 文件中的声明声明其 优先级最低，下一个此类声明声明运算符 其优先级稍高，依此类推。

5.3.3 仅指定优先级

由于 POSIX Yacc 只定义了 、 和 ，它们都定义了优先级和关联性，因此很少 需要注意的是，没有 定义关联性。然而，有时，当试图解决 冲突，优先就足够了。在这种情况下，使用 、 或 可能隐藏未来 （关联性 相关）的冲突将保持隐藏状态。%left%right%nonassoc%left%right%nonassoc

可以解决悬而未决的歧义（参见 Shift/Reduce Conflicts） 明确地。此 shift/reduce 冲突发生在以下情况下： 其中句点表示当前解析状态：else

if e1 then if  e2 then s1 • else s2

冲突涉及规则 '' 的减少，默认情况下，该规则的优先级是其最后一个标记的优先级 （），以及令牌的移动。通常 消除歧义（将 附加到最接近的）， 移位必须是首选，即 的优先级必须为 高于 。但预计两者都不会参与其中 在与关联性相关的冲突中，可以按如下方式指定。IF expr THEN stmtTHENELSEelseifELSETHEN